Agent-based modeling of machine-learning tasks

Abstract

Described is a system for generating an inference output on candidate data based on reference data by identifying a reference subset of the reference data items with a transformation rule shared in common, accessing candidate data that indicates candidate initial states of candidate data items without indicating any transformed states of the candidate data items, and identifying a candidate subset of the candidate data items based on the identified reference subset of the reference data items. The system then transforms the candidate data items in the candidate subset from their candidate initial states to candidate transformed states based on the transformation rule that defines the goal attained by each one of the reference data items in the reference subset by transforming from its reference initial state to its reference transformed state, and generates an output that indicates the candidate transformed states of the candidate subset of the candidate data items.

Description

AGENT-BASED MODELING OF MACHINE-LEARNING TASKSTECHNICAL FIELD

[0001] The present disclosure relates generally to machine learning and, more particularly, to identifying behaviors of data items and performing inferences using machine learning models.BACKGROUND

[0002] Machine learning models are algorithms and techniques performed on computer hardware and are designed to enable computers 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 used on new unlabeled data to generate inferences.BRIEF DESCRIPTION OF THE DRAWINGS

[0003] To easily identify the discussion of any particular element or act, the most significant digit or digits in a reference number refer to the figure number in which that element is first introduced. Some non-limiting examples are illustrated in the figures of the accompanying drawings in which:

[0004] FIG. 1 illustrates an example method for training and making inferences using a machine learning model based on reference and transformed states, according to some examples.

[0005] FIG. 2 illustrates an architecture for training a machine learning model using reference states and performing inferences on new candidate states, according to some examples.

[0006] FIG. 3 illustrates the generation of a transformation rule, according to some examples.

[0007] FIG. 4 illustrates a transformation rule for a candidate initial state, according to some examples.

[0008] FIG. 5 illustrates a machine learning model identifying and using transformation rules, according to some examples.

[0009] FIG. 6 illustrates the machine learning model’s determination between multiple possible transformation rules, according to some examples.

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

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

[0012] FIG. 9 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

[0013] Traditional machine learning models have several pitfalls when it comes to solving puzzles or problem sets that include data items (e.g., in a virtual space). Traditional machine learning models are trained to generalize from a limited set of training data. These models may not perform well when faced with puzzle or problem variations or scenarios that were not part of their training data. This limits the models’ ability to adapt to new scenarios.

[0014] Moreover, traditional models have difficulties handling spatial relationships and location information of data items (such as data items in a two dimensional or three dimensional space, whether real or virtual) effectively. These models often rely on fixed, handcrafted spatial representations.

[0015] Traditional models can also overfit the training data, resulting in poor performance on unseen data. Furthermore, many traditional machine learning models require large amounts of labeled training data to perform well.

[0016] Furthermore, traditional models are not trained to identify the context of a puzzle or problem scenario and are not be able to link goals with behaviors, such as the goal of moving the grey boxes toward the red box.

[0017] Examples of the Artificial Intelligence (Al) system described herein mitigate or eliminate the pitfalls described above. The Al system inputs reference initial and transformed states to a machine learning model described herein to generate transformation rules. These transformation rules can include behavior information or goal information for individual data items, such as movement (e.g., position changes), characteristic changes, or a goal of reaching a certain location with a minimum number of steps. In some cases, the Al system identifies behavior of reference data items transitioning from an initial state to a transformed state, and infers one or more goals of one or more data items based on the identified behavior.

[0018] The Al system described herein trains a machine learning model directly such that the model learns from data items in initial and transformed states and their corresponding characteristics, eliminating the need for manual feature engineering. This can save time and improve the accuracy of feature representation.

[0019] Moreover, the machine learning model described herein is designed to learn behaviors from reference states. This approach enables better generalization as the model adapts to new puzzles, problem sets, or environments, and in scenarios that were not explicitly part of the reference data.

[0020] The machine learning model can perform tasks (e.g., solve problems) in a virtual space (such as a 2D space) with XY coordinates and data item characteristics, allowing the model to handle spatial relationships and location information more effectively. In some cases, the machine learning model operates in multi-dimensional spaces, such as data of the n-th dimension, where each dimension is representative of some characteristic of the corresponding data item. In some cases, the dimensions include data of other associated data items, such as adjacent or other similar data items.

[0021] Moreover, the machine learning model captures temporal dependencies between prior and subsequent states by learning from reference states. This ability to understand how states evolve over time is used by the model to solve puzzles or generate responses to environmental data, which traditional models may not handle as effectively.

[0022] The machine learning model, by learning behaviors from reference states, is less prone to overfitting the reference data, resulting in better performance onunseen data. Traditional models can be more susceptible to overfitting to training data, leading to poorer generalization.

[0023] In summary, the machine learning model described herein addresses many of the limitations and pitfalls associated with traditional machine learning systems when it comes to solving puzzles (e.g., in a virtual space) by providing automated feature learning, improved generalization, spatial and temporal understanding, reduced overfitting, and the like, making it a promising solution for solving puzzles and problem sets efficiently and effectively.TRAINING AND MAKING INFERENCES USING A MACHINELEARNING MODEL BASED ON REFERENCE ANDTRANSFORMED STATES

[0024] FIG. 1 illustrates an example method 100 for training and making inferences using a machine learning model based on reference and transformed states, according to some examples. Although the example method 100 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 100. In other examples, different components of an example device or system that implements the method 100 may perform functions at substantially the same time or in a specific sequence.

[0025] FIG. 1 and other examples described herein are described as being performed by certain systems or certain processes, such as a particular machine learning model, but the processes described herein can be performed by one or more machine learning models and the Al system. In some cases, certain portions of the system or certain steps are disclosed as being performed by the machine learning model. However, it is appreciated that other portions of the system or other steps can be performed by the machine learning model or the Al system.

[0026] Reference data includes training data (e.g., ground truth data) for supervised or unsupervised machine learning model training. The Al system inputs reference data into a machine learning model to identify transformation rules that are later used to generate data items in transformed states. Once the machine learning model is trained, the Al system inputs candidate data items indicating initial statesinto the machine learning model, and the machine learning model generates candidate data items indicating transformed states based on the transformation rules.

[0027] At block 102, the Al system accesses reference data. The reference data includes data that indicates reference initial states of reference data items and reference transformed states of the reference data items.

[0028] FIG. 2 illustrates an architecture for training a machine learning model using reference states and performing inferences on a new candidate initial state, according to some examples. The Al system receives reference initial states, such as reference initial states 202, 204, and 206. The Al system receives reference transformed states, such as reference transformed states 208, 210, and 212.

[0029] In some cases, the reference states include reference data items, such as colored pixels or colored boxes within a virtual area. The virtual area can include data items, such as on a two dimensional grid with X and Y coordinates or three dimensional area with X, Y, and Z coordinates.

[0030] In some cases, the reference data items are shapes (circles, squares, triangles etc.) in a 2D grid, 3D cubes with colors in a 3D grid, nodes in a graph with node features (color, size, edges, etc.), image patches or segments, video segments with objects that have features like color, motion etc., time series data points with features like value, slope etc., game board positions with features like piece types, locations etc., or the like.

[0031] In some cases, the reference data items include training data for training the machine learning model to then perform inferences on candidate data.

[0032] In some cases, the reference initial states and the reference transformed states include reference data items placed across a virtual space. In some cases, every point of the virtual space includes at least one data item. In some cases, the data items are placed in certain portions of the virtual space.

[0033] In some cases, the virtual space includes a two dimensional area, where each reference data item includes an X coordinate, a Y coordinate, and a characteristic for the corresponding reference data item. In other cases, the virtual space is a multi-dimensional area, such as a three dimensional area where each referencedata item includes an X coordinate, a Y coordinate, Z coordinate, and one or more characteristics for the corresponding reference data item.

[0034] In some cases, reference data items can include an implied characteristic. For example, the Al system can infer that there are two objects, one object being on top of another object. As such, the data item that is on top can be included in the characteristic of the reference data item, whereas the data item for the object underneath the top object is stored in the implied characteristic.

[0035] In some cases, the reference data items are pixels or boxes that make up the virtual area. The reference data items can include nodes in a graph or network with features such as connections, centrality, etc., atoms or molecules with features such as element type, charge, bonds, etc., words in a sequence or document with features like part-of-speech, relationships to other words, etc., or the like.

[0036] In some cases, reference data items include patches in an image with features like color, texture, edges, etc., segments in a time-series with features like value, slope, seasonality, etc., characters or tokens in a string with features like case, punctuation, position, etc., vectors in a vector space with features like direction, magnitude, distance to other vectors, etc., entries in a matrix with features like value, row, column, etc., or the like.

[0037] In some cases, reference data items include vertices in a 3D model with features like position, connections, color, etc., agents in a simulation with features like health, inventory, relationships, etc., positions on a game board with features like piece type, possible moves, value, etc., people in a social network with features like demographics, connections, interests, etc., organisms with characteristics like genotype, phenotype, etc., or the like.

[0038] In some cases, at least some of the reference data items correspond to a single object, such as a single pixel or a single box. In some cases, at least some of the reference data items correspond to a group of objects, such as a group pixels or a group of boxes. Reference data items could represent clusters or segments identified within the data, for example, pixels clustered together based on color or other features.

[0039] Reference data items can represent composites built from smaller objects, such as based on identifying meaningful shapes or patterns built from multiple pixels or boxes. Reference data items can be identified at higher levels of abstraction, suchas characters formed from multiple pixels, words from multiple characters, or sentences from words.

[0040] Reference data items can represent the relationships between objects rather than just the objects themselves. For example, edges in a graph linking nodes or adjacent borders between objects. Reference data items can be defined in a hierarchical or nested manner, such as pixels within larger image patches within whole images. Reference data items can represent overlaps or combinations of other items, such as groups sharing common objects or properties.

[0041] In some cases, the size of the virtual space for the reference initial state and the reference transformed state is the same. For example, the reference initial state and the reference transformed state can both be a 10 by 10 grid of data items. In some cases, the size of the virtual space for the candidate initial state and the candidate transformed state is the same. In some cases, the reference and candidate states are of the same size.

[0042] In other cases, the states are of a different size (such as different sizes for reference initial and transformed states, for candidate initial and transformed states, or for reference states and transformed states). For example, the machine learning model can be trained on reference state data of a 10 by 10 grid of boxes. The machine learning model can then make inferences on candidate data that includes a 12 by 12 grid.

[0043] In some cases, the reference data items include size or dimensions (e.g. width and height of an object) information, orientation or direction (e.g. the angle or facing of an object), texture or pattern (e.g. visual patterns within an object) information, motion vectors (e.g. speed and direction of motion), a bounding box (e.g. enclosing rectangle around an object), type or category (e.g. labeling an object as a specific type) of an object, or the like.

[0044] In some cases, reference data items include relationships to other objects (e.g. distance to other objects), hidden state values (e.g. not directly observable but learned features such as overlap as further described herein), node connections in a graph, sequence position for characters / words, game state information like health, score etc., or the like.

[0045] At block 104, the Al system identifies a reference subset of the reference data items with a transformation rule shared in common. The transformation ruledefines a goal attained by each one of the reference data items in the reference subset by transforming from its reference initial state to its reference transformed state.

[0046] For example, in FIG. 2, the Al system assesses the first reference initial state 206 and a first reference transformed state 212. The Al system inputs these states to a machine learning model to generate a transformation rule. The machine learning model is trained to receive as input an initial state and a transformed state, and generate a transformation rule indicative of a goal for one or more reference data items. The transformation rule can then be used by the Al system to generate other reference data items to create a transformed state to fulfill the goal used to generate the transformation rule.

[0047] The system then verifies whether the transformation rule works with the other reference states. The Al system accesses the second reference initial state 202 and the second reference transformed state 208 and uses the transformation rule on the second reference initial state 202 to generate a generated second reference transformed state.

[0048] The Al system then checks whether the generated second reference transformed state is the same with the received second reference transformed state. If the same, then the Al system saves an indication in a database that the transformation rule worked with the second set of reference state data.

[0049] In some cases, the Al system determines that the generated second reference transformed state is not the same with the received second reference transformed state. In such cases, the Al system saves an indication that the transformation did not work with the second set of reference state data. In some cases, the Al system saves an indication of how close the generated second reference transformed state is to the received second reference transformed state. For example, the Al system can find a means squared error, a percentage correct or incorrect, a number of correct or incorrect transformations, a measure of how many sub -components were correct, or the like.

[0050] The system iteratively repeats this check across the other reference states, such as via the third reference initial state 204 and the second reference transformed state 210. Upon confirming that the transformation rule generated using the first reference states work with the other reference states (e.g., using the transformationrule on the reference initial state generates the correct reference transformed state), the system proceeds to block 106 of FIG. 1.

[0051] In some cases, if the transformation rule did not produce the correct result with the second reference states, then the Al system immediately iterates back to the first reference states and identifies another transformation rule. In other cases, the Al system continues to test the other reference states for verification.

[0052] In some cases, the system proceeds to block 106 if all (or at least some) of the reference states are confirmed to work using the transformation rule. In other cases, the system proceeds to block 106 if the number of reference states that are confirmed using the transformation rule meet or exceed a certain threshold amount or percentage.

[0053] If the transformation rule does not accurately transform some of the other reference initial states into their corresponding reference transformed states, this indicates the initial transformation rule was incomplete or incorrect. In this case, the Al system can return to the first reference state to re-evaluate the initial rule generation process and identify why the rule failed for those states.

[0054] In some cases, the Al system regenerates the transformation rule from scratch using different parameters, such as based on different characteristics of the data items. In some cases, the Al system identifies modifications that can be made to the transformation rule based on the closeness to the correct reference transformation state.

[0055] In some cases, the Al system regenerates a rule which represents a subset or superset of the transformation rule. In some cases, the Al system accesses a rule, such as the rule to turn all blue squares into green triangles. The Al system can access such a rule based on other reference data items in certain reference states. For example, there could be a first set of reference data where data items in an initial state have blue squares and the transformed states have the blue squared turned into green triangles. The Al system regenerates the rule to be of a subset of the changes (such as turning all blue squares of at least 9 pixels in size into green triangles) or a superset (such as turning all blue objects of any shapes into green triangles).

[0056] In some cases, the Al system determines that the scope of the rule was too narrow and needs to be expanded, such as by considering another characteristic ora different characteristic of the reference data items. The Al system then performs another iteration of identifying values for the other or different characteristic identified from one set of reference states, and tests with other reference states.

[0057] In some cases, the Al system determines to assess another characteristic based on a determination that the transformation is too complex for the simplicity of the initial rule and more nuance is needed, or vice versa, that incorrect assumptions were made about the nature of the transformation, or the like, which can trigger another set of iterative reference state transformation rule generation and testing.

[0058] Through this iterative process of rule generation, validation, and refinement, the Al system can incrementally improve and expand the database of transformation rules until the Al system reliably identifies one or more transformation rules that can transform all reference states or transforms the highest number of initial states correctly (or the closest to the correct transformation).

[0059] In some cases, there are multiple distinct transformation behaviors and the initial rule only captured one subset of them. In such cases, the Al system checks the other rules with the reference state dataset to confirm which of the rules perform the best to transform the initial reference states to the transformed reference states.

[0060] At block 106, the Al system accesses candidate data. The candidate data can include initial states of candidate data items. The candidate data items can be inputted to the machine learning model to generate candidate transformed states. The Al system can receive the candidate initial states without indicating any transformed states of the candidate data items.

[0061] At block 108 of FIG. 1, the Al system identifies a candidate subset of the candidate data items based on the identified reference subset of the reference data items. For example, the Al system identifies that certain candidate data items of the candidate initial state include similar characteristics to reference data items in the reference subset of the reference initial state.

[0062] The Al system can determine similarity based on one or more characteristics of the data items, such as the number of data items in the reference and candidate initial state dataset, behavior or identified goals of data items, dimensionality of the data for the data items, size of the virtual space, adjacent data items or dataitems that are of a certain number distance, or the like (such as the examples further described herein).

[0063] At block 110 of FIG. 1, the Al system transforms the candidate data items in the candidate subset from their candidate initial states to candidate transformed states based on the transformation rule. For example, the Al system can receive as input candidate initial states to transform these initial states to candidate transformed states, and generate an output that indicates the candidate transformed states. In other cases, the Al system generates candidate data items in candidate initial states and transforms these initial states to candidate transformed states.

[0064] The transformation rule defines the goal attained by each one of the reference data items in the reference subset by transforming from its reference initial state to its reference transformed state.

[0065] Once the transformation rule is generated using the first reference initial state 206 and the first reference transformed state 212, and the transformation rule is tested with the second and third reference initial states 202, 204 and the second and third reference transformed states 208, 210, the Al system receives candidate initial state 214.

[0066] The Al system identifies that certain characteristics of the candidate initial state are similar to the reference initial states, such as the number of data items.

[0067] At block 112 of FIG. 1, the Al system generates an output that indicates the candidate transformed states of the candidate subset of the candidate data items. The transformed states of the candidate subset are attained based on the goal defined by the transformation rule shared in common, the goal identified when identifying the reference subset. The Al system uses the transformation rule on the candidate initial state 214 to generate the candidate transformed state 216.

[0068] 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 an external data source that provides candidate and reference state information, whereby the machine inputs data to the Al system and the Al system responds with output from the machine learning model. The responses can affect the operations of the connected machine.

[0069] The machine learning model described herein dynamically generates transformation rules based on one or more characteristics, such as goals and behaviors of data items. The machine learning model can also generate transformation rules based on other 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 and remodifies transformation rules to adapt to the needs and requirements of the machine.

[0070] 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 to interpret sensor data, make real-time decisions, and send responses to self-driving cars on changing road conditions.

[0071] In some cases, the machine learning models can be connected to surveillance cameras, whereby the machine learning model performs intelligent video analytics for identifying anomalies and detecting potential security threats. In some cases, machine learning models can be connected to a wide range of Internet of Things (loT) devices, enabling smart and adaptive automation in smart homes, cities, and industries.

[0072] 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, medical devices, and image understanding. Machine learning models can be connected to gaming environments, providing adaptive gameplay, opponent Al, and personalized experiences.

[0073] 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.

[0074] In such cases, the systems can provide historical data, such as reference state data, or data gathered from other machines that are working property, and the machine learning model can adapt or generate transformation rules to be used by the currently connected machine.GENERATING A TRANSFORMATION RULE

[0075] FIG. 3 illustrates the generation of a transformation rule, according to some examples. In some cases, the Al system generates a machine learning model that identifies behaviors or goals of reference data items, such as movements, resizing, copying, scaling, deleting, adding new characteristics such as color, or the like. In some cases, the Al system identifies behaviors of reference data items, and infers goals from these behaviors.

[0076] The Al system can receive a reference initial state 302 and a reference transformed state 304. The reference states can include a virtual space, such as a 10 by 10 grid of data items, such as pixels or boxes. Each data item can include a characteristic, such as a color.

[0077] The Al system can input the reference initial state 302 and a reference transformed state 304 to a machine learning model. The machine learning model can identify reference data items. In the example of FIG. 3, the machine learning model identifies data items as shown in the reference initial state 306 that corresponds to the inputted reference initial state 302.

[0078] In the reference initial state 306, a first data item 318, a second data item 320, a third data item 322, and a fourth data item 324 are identified by the machine learning model. The Al system then identifies data items in the reference transformed state 304. As shown in the reference transformed state 304, the machine learning model identifies a first data item 310, a second data item 312, a third data item 314, and a fourth data item 316.

[0079] The machine learning model checks if the data items identified in the reference initial state 306 maps to data items identified in the reference transformed state 308. For example, the machine learning model initially checks whether the number of data items identified in the reference initial state 306 is the same as the reference transformed state 308.

[0080] In some cases, the machine learning model checks the reference initial state and the reference transformed state to determine whether there are the same number of items of certain categories identified. For example, the machine learning model checks whether 3 squares and 2 triangles that were identified in the initial states are also identified in the transformed states. In some cases, the machine learning model checks whether a number of the categories of objects are the same, such as 3 squares and 2 triangles in the initial states and 5 squares and 5 triangles in the transformed states both have 2 main categories of objects (e.g., first being squares, second being triangles).

[0081] In some cases, the Al system identifies categories based on different shapes, such as squares or triangles. In some cases, the Al system identifies categories based on groups of shapes, such as one category being a polyhedron, or another set of categories based on the number of sides of the shape. In some cases, the machine learning model can check the transformed state for a subset of the items in the initial state, such as if the transformation rule includes a preference to make a data item disappear, such as changing the data item’s color to match the color of the background or superimposing an overlay of a different color over the reference data item in the initial state.

[0082] In some cases, the machine learning model matches data items in the initial state with data items in the transformed state. The machine learning model matches the data items based on similarities in characteristics.

[0083] The machine learning model matches data items using characteristics such as color. The first data item 318 in the reference initial state 306 matches color with the first data item 310 in the reference transformed state 308.

[0084] The machine learning model identifies three other data items, the second data item 320, the third data item 322, and the fourth data item 324. These three data items in the reference initial state 306 have the same color as the second data item 312, the third data item 314, and the fourth data item 316 in the reference transformed state 308.

[0085] The machine learning model determines that the size, color, and number of these similar data items are the same in both the initial and transformed states, and thus, determines that the data items identified in the initial state map to the data items identified in the transformed state.

[0086] The machine learning model can also use one or more other characteristics to map the data items from the initial state to the transformed state. For example, the machine learning model identifies the closest reference data items to the first data item 318. As such, the second data item 320 is mapped to the second data item 312 as they are closest to the top border of the first data item 318, 310.

[0087] The machine learning model can map data items using a movement characteristic. For example, the second data item 320 is mapped to the second data item 312 as the second data item 320 is moved to border the first data item 318 with the least number of steps.

[0088] In some cases, the machine learning model looks for the same number of data items to create a subset of data items in the transformed state as the initial state. For example, if four data items were identified in the reference initial state 306 to be placed in a subset, the machine learning model looks for four reference data items also in the reference transformed state 308. As such, the identifying of the reference subset includes identifying a same number of reference data items that are identified in the reference subset of the reference initial state in the reference transformed state.

[0089] In some cases, the machine learning model assesses the reference transformed state and identifies certain data items based on the number of data items identified in the reference initial state. For example, if the machine learning model identified the four data items in reference initial state 306, the machine learning model looks for four data items in the reference transformed state 308. As such, identifying of the candidate subset of the candidate data items includes identifying a same number of candidate data items for the candidate subset as a number of reference data items in the reference subset.

[0090] The machine learning model determines one or more behaviors for individual data items. The machine learning model identifies that the first data item 318 does not change from the reference initial state 306 to the reference transformed state 308. However, the second data item 312, a third data item 314, and a fourth data item 316 change location.

[0091] The behavior can include a movement, such as a vertical, horizontal, or diagonal movement on the grid. The behavior can include a velocity or acceleration of movements (such as if there are more than one transformed states).The behavior can include a relative movement or distance, such as a vertical movement of the second reference data item to be bordering the first reference data item, a horizontal movement of the third reference data item to be bordering the first reference data item, and a diagonal movement of the fourth reference data item to be bordering the first reference data item.

[0092] In some cases, the behavior includes a scaling (double in size), copying of a data item, deleting of a data item, changing of a characteristic (such as color), changing of a distance of the data item to another data item, rotating of a data item, rotation of a data item, flipping of a data item on an axis, creation of a data item, intersecting of a data item, overlapping of a data item (such as in the z- index), or the like.

[0093] In some cases, the machine learning model determines the transformation rule by inferring the goal attained by each one of the reference data items in the reference subset in transforming from the corresponding reference data items' reference initial state to the reference transformed state. As shown in the example of FIG. 3, the goal for the second, third, and fourth data item is to be transformed to take the smallest number of steps to be bordering the first data item.

[0094] In some cases, the data items can include information related to the positioning in the virtual space, such as an X value being the horizontal positioning and Y value being the vertical positioning in the virtual space. The machine learning model is trained to identify one or more commonalities between the transformed states and the initial states to identify goals from behaviors of data items. For example, if the transformed state includes data items located at the bottom of the virtual space (the bottom being when the Y value is 0), the machine learning model identifies a goal of moving data items to have a Y value in the virtual space as 1. In some cases, if the transformed data items are consistently one pixel or location lower than the initial state data items, the machine learning model identifies the goal of the data items to have a y value determined by: y new = y old - 1.

[0095] In some cases, the machine learning model identifies correlations between or among a range of different properties, such as color, position, or the like. The machine learning model can identify correlations in absolute or relative terms and find candidate goals with the highest correlation. In some cases, the machinelearning model can identify multiple correlations and test the various different correlations. For example, the machine learning model can identify three correlations and test the transformation rule determined based on individual correlations to determine that the second or third correlation performs best on the other reference states.

[0096] In some cases, the machine learning model groups one or more data items based on inferred goals, behaviors, or characteristics of data items. The second data item 314, and the third data item 316 can be grouped based on a color (e.g., characteristic), a behavior (movement on the grid when going from an initial state to a transformed state), an inferred goal (smallest steps taken to border the first data item, a distance or number of movements (e.g., moving 2 blocks over) or an amount of change in a characteristic (two shades darker), a relative distance such as bordering another data item or one step away from another data item, or the like.

[0097] The machine learning model can group items by identifying a reference subset of the reference data items with a transformation rule shared in common. The transformation rule can define a goal attained by each one of the reference data items in the reference subset that transforms the grid from its reference initial state to its reference transformed state.

[0098] In some cases, the machine learning model uses one or more characteristics to map, group, determine behavior of, determine goals of a single or a group of data items. For example, the machine learning model can identify an overall characteristic of the grid, such as based on a sum, an average, or other identified metric. In some cases, the characteristic is data item specific. In some cases, the characteristic is a relative metric of a data item or group of data item compared to another data item or group of data item.

[0099] In some cases, the characteristic includes a total number of data items in a certain group of data items or the entire network. For example, the machine learning model can learn that once a number of data items exceeds a certain threshold number of data items, the transformed step includes a smaller number of those data items.

[0100] The Al system uses a combined order of specific procedures that dynamically identifies and maps reference data items, identifies behaviors and infers goals ofreference data items, and performs inferences on candidate initial states to generate a candidate transformed state. In response to certain reference state input data and candidate initial state input data of a grid of data items in a two dimensional virtual state, the Al system determines the behavior and goals of reference data items and uses the transformation to data items identified in the candidate input data.

[0101] Although examples described herein describe one type of model, such as a machine learning model, it is appreciated that such features can be used on 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.

[0102] Although examples described herein describe one type of data items, it is appreciated that such features can be used on other types of models such as a model of nodes, such as a cluster of nodes or a group of interconnected nodes, and vice versa.

[0103] Although characteristics described herein can be used, inputted, or accessed in one feature, such as a color being used to map data items, it is appreciated that the characteristics can be used, inputted, or accessed to other features (such as using color to group data items or using color to identify behaviors of data items) and that features can be used, inputted, or accessed to other characteristics (such as identifying movement or distance to map data items).

[0104] Systems and methods described herein include training a machine learning network, such as training to make correct inferences on candidate data. The machine learning network can be trained to identify behaviors or goals of dataitems in reference state data. The machine learning algorithm can be trained using reference initial states and transformed states that include reference data items.

[0105] Training of models, such as artificial intelligence models, is necessarily rooted in computer technology, and improves modeling technology by using training data to train such models and thereafter using the models on new inputs to make inferences on the new inputs. Here, the new inputs can be new candidate state data, including candidate initial state data and candidate transformed state data that include candidate data items. The trained machine learning model can determine behaviors or goals of reference data items based on reference state data, and transform candidate data items using such transformation rules.

[0106] In some cases, the Al system inputs characteristics into the trained machine learning model to guide the machine learning model to assess certain characteristics (such as color, shape, size, etc.). The machine learning model identifies different combinations of such characteristics to identify one or more behaviors or goals (as further described herein) for the problem set to apply to future candidate data sets.

[0107] Such training involves complex processing that typically requires a lot of processor computing and extended periods of time with large training data sets, which are typically performed by massive server systems. Training of models can require logistic regression and / or forward / backward propagating of training data that can include input data and expected output values that are used to adjust parameters of the models. Such training is the framework of machine learning algorithms that enable the models to be used on new and unseen data (such as new candidate data) and make predictions that the model was trained for based on the weights or scores that were adjusted during training. Such training of the machine learning models described herein reduces false positives and increases the performance by identifying goal and behavior information for data items.

[0108] In some cases, the machine learning model identifies a background data item, such as background data item 326. In some cases, the background data item only includes a coordinate value, such as an X or Y location. In some cases, the background data item is identified to note that no changes are initiated based on the background data item, nor any identification of behavior or goals.USING THE TRANSFORMATION RULE TO CANDIDATE STATEINPUT

[0109] FIG. 4 illustrates the use of a transformation rule on a candidate initial state, according to some examples. The machine learning model receives as input the candidate input state 402.

[0110] The machine learning model identifies a first data item 422 and the second, third, fourth, and fifth data items 424, 406, 408, and 410. The machine learning model identifies the first data item 422 as having similar (within a certain threshold value) or the same characteristics as the first data item 318 of the reference initial state shown in FIG. 3. The machine learning model identifies the similarity based on the size of the collective data item (composed of 4 pixels or boxes), having similar or the same characteristic (such as the etching or color), or the like.[oni] The machine learning model identifies that the first data item 318 of the reference initial state did not move when transformed to the reference transformed state. Thus, the machine learning model does not make changes to the first data item 422 in the candidate initial state.

[0112] The machine learning model identifies that the second, third, fourth, and fifth data items 424, 406, 408, and 410 share similar (with a certain threshold value) or the same characteristics as the second, third, and fourth data items 320, 322, and 324 of the reference initial state shown in FIG. 3. The machine learning model identifies the similarity based on the size of the collective data item (composed of 1 pixel or box), having similar or the same characteristic (such as the etching or color), or the like.

[0113] The machine learning model identifies that the second, third, and fourth data items 320, 322, 324 of the reference initial state have goals to take the least number of steps to border the first data item. Thus, the machine learning model transforms the second, third, fourth, and fifth data items 424, 406, 408, and 410 in the candidate initial state to the second, third, fourth, and fifth data items 414, 416, 418, and 420 which now border the first data item 412.IDENTIFYING AND USING TRANSFORMATION RULES

[0114] FIG. 5 illustrates using a machine learning model to identify and use transformation rules, according to some examples. The first reference initial state 502 includes an identification of a large reference data item in the middle, and two reference data items in the corners. The first reference transformed state 508 includes an identification of a similar large reference data item in the middle, but the two reference data items in the corners have overlapped with a part of the larger reference data item.

[0115] The machine learning model identifies the middle large reference data items and the two smaller reference data items in the corners and maps the data items between the first reference initial state 502 and the first reference transformed state 508. The machine learning model determines that the behavior change of the smaller reference data items is a movement to overlap with the larger reference data item in the middle. The machine learning model uses this information to infer that the goal is to take the least number of movements to overlap with the larger reference data item in the middle.

[0116] The machine learning model verifies this goal by using the goal to reference data items in the second and third reference initial states 504, 506 to generate second and third reference transformed states 510, 512. The second and third reference transformed states 510, 512 is tested with ground truth information received as input, which includes ground truth second and third reference transformed states.

[0117] If the second and third reference transformed states 510, 512 are the same as the ground truth second and third reference transformed states, the machine learning model then uses the one or more goals of individual data items to a candidate initial state 514 to the generate the candidate transformed state 516.DETERMINATION BETWEEN MULTIPLE TRANSFORMATIONRULES

[0118] FIG. 6 illustrates the machine learning model's determination between multiple possible transformation rules, according to some examples. The machine learning model takes the first reference initial state 602 and the first reference transformed state 606 and generates a transformation rule.

[0119] The machine learning model verifies the transformation rule on a second reference initial state 604 and a second reference transformed state 608. However, in some cases, multiple transformation rules can be identified from the same reference dataset.

[0120] A first transformation rule can include, in the example of FIG. 6, identifying an intersection between two data items, and the transformation is to create a new characteristic for the surrounding blocks of the individual box or pixel of the intersection. The machine learning model can use the first transformation rule on a candidate initial state 610 to generate the correct candidate transformed state 614 by using the correct candidate transformation.

[0121] However, in some cases, the incorrect transformation rule can be identified. For example, the transformation rule could be to take the reference data item that is of a single row or column and extends to the entire width or height of the virtual space, take an individual box or pixel at around % of its length, and add a new characteristic to all surrounding blocks of that identified box or pixel at the % length mark. In this circumstance, the machine learning model could have determined that the transformation rule works given that the rule was verified using the second reference state input. However, the machine learning model incorrectly uses this on the candidate initial state to generate an incorrect candidate transformed state 612.

[0122] In some cases, a transformation rule is generated using one reference dataset but failed to verify based on the use of the transformation rule on other reference datasets. In some cases, the transformation rule generated using one reference dataset is verified with other reference datasets, but still fails to generate an incorrect candidate transformed state.

[0123] In such cases, the system can iteratively return to the first reference dataset or another reference dataset and modify one or more parameters to obtain the transformation rule. The system can test another pair of reference datasets to generate a different transformation rule. The system can create more or less groups of data items, such as based on characteristics, behaviors, or the like as further described herein.

[0124] In some cases, a non-transitory medium can be used to implement one or more features described herein. In some cases, a non-transitory medium includes a tangible medium.MACHINE-LEARNING PIPELINE

[0125] FIG. 7 is a flowchart depicting a machine-learning pipeline 800, and FIG. 8 is a schematic diagram illustrating the training and use of an example machinelearning program. FIG. 7 and FIG. 8 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. 7 and FIG. 8 are example features can be used on the examples described herein, where applicable. In some cases, the features described herein can be used on one or more machine learning models described in FIG. 7 and FIG. 8.

[0126] The machine-learning pipeline 800 may be used to generate a trained machine learning model, for example the trained machine-learning program 802 of FIG. 8, to perform operations associated with searches and query responses.Overview

[0127] 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 rewardsor penalties. Examples of reinforcement learning algorithms include Q- learning and policy gradient methods.

[0128] 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 supervised learning 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.

[0129] 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.

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

[0131] 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 (for example, by providing a value that is a real number) to perform a regression task.

[0132] Generating a trained machine-learning program 802 may include multiple phases that form part of the machine-learning pipeline 800, including for example the following phases illustrated in FIG. 7:• Data collection and preprocessing 702: 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 704: This phase may include selecting and transforming the training data 806 to create features that are useful for predicting the target variable. Feature engineering may include (1) receiving features 808 (e.g., as structured or labeled data in supervised learning) or (2) identifying features 808 (e.g., unstructured or unlabeled data for unsupervised learning) in training data 806.• Model selection and training 706: 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 708: This phase may include evaluating the performance of a trained model (e.g., the trained machine-learning program 802) 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 710: This phase involves using a trained model (e.g., trained machine-learning program 802) to generate predictions on new, unseen data.• Validation, refinement or retraining 712: This phase may include updating a model based on feedback generated from the prediction phase, such as new data or user feedback.• Deployment 714: This phase may include integrating the trained model (e.g., the trained machine-learning program 802) 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.

[0133] FIG. 8 illustrates further details of two example phases, namely a training phase 804 (e.g., part of the model selection and trainings model selection and training 706) and a prediction phase 810 (part of prediction 710). Prior to the training phase 804, feature engineering 704 is used to identify features 808. This may include identifying informative, discriminating, and independent features for effectively operating the trained machine-learning program 802 in pattern recognition, classification, and regression. In some examples, the training data 806 includes labeled data, known for pre-identified features 808 and one or more outcomes. Each of the features 808 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 806). Features 808 may also be of different types, such as numeric features, strings, and graphs, and may include one or more of content 812, concepts 814, attributes 816, historical data 818 , or user data 820, merely for example.

[0134] In training phase 804, also referred to herein as a training period, the machinelearning pipeline 800 uses the training data 806 to find correlations among the features 808 that affect a predicted outcome or prediction / inference data 822. 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.

[0135] With the training data 806 and the identified features 808, the trained machinelearning program 802 is trained during the training phase 804 during machine-learning program training 824. The machine-learning program training 824 appraises values of the features 808 as they correlate to the training data 806. The result of the training is the trained machine-learning program 802 (e.g., a trained or learned model).

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

[0137] In some examples, a neural network may be generated during the training phase 804, and implemented within the trained machine-learning program 802. The neural network 826 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.

[0138] Each neuron in the neural network 826 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 of activation functions and weights enable neural networks to modelcomplex relationships between inputs and outputs, and to generalize to new inputs that were not seen during training.

[0139] In some examples, the neural network 826 may also be one of several different types of neural networks, such as a single-layer feed-forward 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.

[0140] In addition to the training phase 804, 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.

[0141] 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.

[0142] In prediction phase 810, also referred to herein as a runtime period, the trained machine-learning program 802 uses the features 808 for analyzing query data 828 to generate inferences, outcomes, or predictions, as examples of a predict! on / inference data 822. For example, during prediction phase 810, the trained machine-learning program 802 generates an output. Query data 828 is provided as an input to the trained machine-learning program 802, and the trained machine-learning program 802 generates the prediction / inference data 822 as output, responsive to receipt of the query data 828. 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.

[0143] In some examples, the trained machine-learning program 802 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 806. For example, generative Al can produce text, images, video, audio, code, or synthetic data similar to the original data but not identical.1. 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.

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

[0145] FIG. 9 is a diagrammatic representation of the machine 900 within which instructions 902 (e.g., software, a program, an application, an applet, an app, or other executable code) for causing the machine 900 to perform any one or more of the methodologies discussed herein may be executed. For example, the instructions 902 may cause the machine 900 to execute any one or more of the methods described herein. The instructions 902 transform the general, nonprogrammed machine 900 into a particular machine 900 programmed to carry out the described and illustrated functions in the manner described. The machine 900 may operate as a standalone device or may be coupled (e.g., networked) to other machines. In a networked deployment, the machine 900 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 900 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 902, sequentially or otherwise, that specify actions to be taken by the machine 900. Further, while a single machine 900 is illustrated, the term “machine" shall also be taken to include a collection of machines that individually or jointly execute the instructions 902 to perform any one or more of the methodologies discussed herein. In some examples, the machine 900 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.

[0146] The machine 900 may include processors 904, memory 906, and input / output I / O components 908, which may be configured to communicate with each other via a bus 910. In an example, the processors 904 (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 912 and a processor 914 that execute the instructions 902. 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. 9 shows multiple processors 904, the machine 900 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.

[0147] The memory 906 includes a main memory 916, a static memory 918, and a storage unit 920, both accessible to the processors 904 via the bus 910. The main memory 906, the static memory 918, and storage unit 920 store the instructions 902 embodying any one or more of the methodologies or functions described herein. The instructions 902 may also reside, completely or partially, within the main memory 916, within the static memory 918, within machine-readable medium 922 within the storage unit 920, within at least one of the processors 904 (e.g., within the processor’s cache memory), or any suitable combination thereof, during execution thereof by the machine 900.

[0148] The I / O components 908 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 908 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 908 may include many other components that are not shown in FIG. 9. In various examples, the I / O components 908 may include user output components 924 and user input components 926. The user output components 924 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 raytube (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 926 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.

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

[0150] Moreover, the communication components 928 may detect identifiers or include components operable to detect identifiers. For example, the communication components 928 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, DataglyphTM, 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 identified via the communication components 928, 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.

[0151] The various memories (e.g., main memory 916, static memory 918, and memory of the processors 904) and storage unit 920 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 902), when executed by processors 904, cause various operations to implement the disclosed examples.

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

[0153] 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.

[0154] Example l is a system comprising: at least one processor; and at least one memory component storing instructions that, when executed by the at least one processor, cause the at least one processor to perform run-time operations comprising: accessing reference data that indicates reference initial states of reference data items and reference transformed states of the reference data items; identifying a reference subset of the reference data items with a transformation rule shared in common, the transformation rule defining a goal attained by each one of the reference data items in the reference subset by transforming from its reference initial state to its reference transformed state; accessing candidate data that indicates candidate initial states of candidate data items without indicating anytransformed states of the candidate data items; identifying a candidate subset of the candidate data items based on the identified reference subset of the reference data items; transforming the candidate data items in the candidate subset from their candidate initial states to candidate transformed states based on the transformation rule that defines the goal attained by each one of the reference data items in the reference subset by transforming from its reference initial state to its reference transformed state; and generating an output that indicates the candidate transformed states of the candidate subset of the candidate data items, the transformed states of the candidate subset attaining the goal defined by the transformation rule shared in common by the reference subset.

[0155] In Example 2, the subject matter of Example 1 includes, wherein the reference initial states and the reference transformed states indicate reference data items placed in a virtual space.

[0156] In Example 3, the subject matter of Example 2 includes, wherein the virtual space includes a two dimensional area, wherein each reference data item includes an X coordinate, a Y coordinate, and a characteristic of the corresponding reference data item.

[0157] In Example 4, the subject matter of Example 3 includes, wherein the characteristic includes a color of the corresponding reference data item.

[0158] In Example 5, the subject matter of Examples 2-4 includes, wherein at least some of individual reference data items each correspond to at least one of a single pixel or box of the virtual space.

[0159] In Example 6, the subject matter of Examples 2-5 includes, wherein at least some of individual reference data items each correspond to at least one of a group of pixels or a group of boxes of the virtual space.

[0160] In Example 7, the subject matter of Examples 2-6 includes, wherein a size of a reference virtual space of the reference initial states and the reference transformed states and a size of a virtual space of the candidate initial states and the candidate transformed states are the same.

[0161] In Example 8, the subject matter of Examples 2-7 includes, wherein a size of the virtual space of the reference initial states and the reference transformed states are the same, a size of a virtual space of the candidate initial states and thecandidate transformed states are the same, and the sizes of the virtual space of the reference states are different than the sizes of the virtual space of the candidate states.

[0162] In Example 9, the subject matter of Examples 1-8 includes, wherein the identifying of the reference subset includes identifying a same number of reference data items in the reference transformed state to a number of reference data items that are identified in the reference subset of the reference initial state.

[0163] In Example 10, the subject matter of Examples 1-9 includes, wherein the identifying of the candidate subset of the candidate data items includes identifying a same number of candidate data items in the reference subset to a number of candidate data items that are identified in the candidate subset.

[0164] In Example 11, the subject matter of Examples 1-10 includes, wherein the operations further comprise mapping the reference data items of the reference subset in the reference initial states to the reference data items of the reference transformed state based on one or more characteristics of the reference data items.

[0165] In Example 12, the subject matter of Example 11 includes, ) at least one of a movement characteristic or a distance characteristic.

[0166] In Example 13, the subject matter of Examples 1-12 includes, the transformation rule is determined by inferring, via a machine-learning model, the goal attained by each one of the reference data items in the reference subset in transforming from the corresponding reference data items' reference initial state to the reference transformed state.

[0167] In Example 14, the subject matter of Examples 1-13 includes, wherein the transforming of the candidate data items include moving a portion of the candidate data items from one location to another generating the candidate transformed state.

[0168] In Example 15, the subject matter of Example 14 includes, wherein the moving of the portion of the candidate data items includes moving a plurality of the candidate data items adjacent to a further candidate data item with minimal movement steps within a virtual two dimensional grid.

[0169] In Example 16, the subject matter of Examples 14-15 includes, wherein the moving of the portion of the candidate data items includes moving a plurality ofthe candidate data items coincident with a further candidate data item with minimal movement steps within a virtual two dimensional grid.

[0170] In Example 17, the subject matter of Examples 1-16 includes, wherein the transforming of the candidate data items include changing a portion of the candidate data items from one color to another color.

[0171] In Example 18, the subject matter of Examples 1-17 includes, the identifying of the reference subset includes identifying a reference subset based on a first reference initial state and a first reference transformed state, and verifying the transformation rule causing the identification of the reference subset by applying the transformation rule to a second reference initial state causing the generation of a second reference transformed state, and comparing the second reference transformed state to a ground truth second reference transformed state.

[0172] In Example 19, the subject matter of Examples 1-18 includes identifying a subset of the transformation rule or a superset of the transformation rule, wherein transforming the candidate data items is based on the subset or superset of the transformation rule.

[0173] Example 20, the subject matter of Examples 1-19 includes the transformation rule being based on a number of a category of reference data items.

[0174] Example 21, the subject matter of Examples 1-20 includes receiving a selection of one or more characteristics of the reference data items, and identifying the transformation rule based on the received selection.

[0175] Example 22 is a method comprising: accessing reference data that indicates reference initial states of reference data items and reference transformed states of the reference data items; identifying a reference subset of the reference data items with a transformation rule shared in common, the transformation rule defining a goal attained by each one of the reference data items in the reference subset by transforming from its reference initial state to its reference transformed state; accessing candidate data that indicates candidate initial states of candidate data items without indicating any transformed states of the candidate data items; identifying a candidate subset of the candidate data items based on the identified reference subset of the reference data items; transforming the candidate data items in the candidate subset from their candidate initial states to candidate transformed states based on the transformation rule that defines the goal attained by each oneof the reference data items in the reference subset by transforming from its reference initial state to its reference transformed state; and generating an output that indicates the candidate transformed states of the candidate subset of the candidate data items, the transformed states of the candidate subset attaining the goal defined by the transformation rule shared in common by the reference subset.

[0176] Example 23 is a non-transitory computer-readable storage medium or tangible medium storing instructions that, when executed by at least one processor, cause the at least one processor to perform operations comprising: accessing reference data that indicates reference initial states of reference data items and reference transformed states of the reference data items; identifying a reference subset of the reference data items with a transformation rule shared in common, the transformation rule defining a goal attained by each one of the reference data items in the reference subset by transforming from its reference initial state to its reference transformed state; accessing candidate data that indicates candidate initial states of candidate data items without indicating any transformed states of the candidate data items; identifying a candidate subset of the candidate data items based on the identified reference subset of the reference data items; transforming the candidate data items in the candidate subset from their candidate initial states to candidate transformed states based on the transformation rule that defines the goal attained by each one of the reference data items in the reference subset by transforming from its reference initial state to its reference transformed state; and generating an output that indicates the candidate transformed states of the candidate subset of the candidate data items, the transformed states of the candidate subset attaining the goal defined by the transformation rule shared in common by the reference subset.

[0177] Example 24 is at least one machine-readable medium including instructions (e.g., a non-transitory computer-readable storage medium) that, when executed by processing circuitry, cause the processing circuitry to perform operations to implement any of Examples 1-23.

[0178] Example 25 is an apparatus comprising means to implement any of Examples 1-23.

[0179] Example 26 is a system to implement any of Examples 1-23.

[0180] Example 27 is a method to implement any of Examples 1-23.CONCLUSION

[0181] 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 any combination of the items in the list. Likewise, the term “and / 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.

[0182] 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.

[0183] 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.

Claims

CLAIMSWhat is claimed is:

1. A system comprising: at least one processor; and at least one memory component storing instructions that, when executed by the at least one processor, cause the at least one processor to perform run-time operations comprising: accessing reference data that indicates reference initial states of reference data items and reference transformed states of the reference data items; identifying a reference subset of the reference data items with a transformation rule shared in common, the transformation rule defining a goal attained by each one of the reference data items in the reference subset by transforming from its reference initial state to its reference transformed state; accessing candidate data that indicates candidate initial states of candidate data items without indicating any transformed states of the candidate data items; identifying a candidate subset of the candidate data items based on the identified reference subset of the reference data items; transforming the candidate data items in the candidate subset from their candidate initial states to candidate transformed states based on the transformation rule that defines the goal attained by each one of the reference data items in the reference subset by transforming from its reference initial state to its reference transformed state; and generating an output that indicates the candidate transformed states of the candidate subset of the candidate data items, the transformed states of the candidate subset attaining the goal defined by the transformation rule shared in common by the reference subset.

2. The system of claim 1, wherein the reference initial states and the reference transformed states indicate reference data items placed in a virtual space.

3. The system of claim 2, wherein the virtual space includes a two dimensional area, wherein each reference data item includes an X coordinate, a Y coordinate, and a characteristic of the corresponding reference data item.

4. The system of claim 3, wherein the characteristic includes a color of the corresponding reference data item.

5. The system of claim 2, wherein at least some of individual reference data items each correspond to at least one of a single pixel or box of the virtual space.

6. The system of claim 2, wherein at least some of individual reference data items each correspond to at least one of a group of pixels or a group of boxes of the virtual space.

7. The system of claim 2, wherein a size of a reference virtual space of the reference initial states and the reference transformed states and a size of a virtual space of the candidate initial states and the candidate transformed states are the same.

8. The system of claim 2, wherein a size of the virtual space of the reference initial states and the reference transformed states are the same, a size of a virtual space of the candidate initial states and the candidate transformed states are the same, and the sizes of the virtual space of the reference states are different than the sizes of the virtual space of the candidate states.

9. The system of claim 1, wherein the identifying of the reference subset includes identifying a same number of reference data items in the reference transformed state to a number of reference data items that are identified in the reference subset of the reference initial state.

10. The system of claim 1, wherein the identifying of the candidate subset of the candidate data items includes identifying a same number of candidate data items in the reference subset to a number of candidate data items that are identified in the candidate subset.

11. The system of claim 1, wherein the operations further comprise mapping the reference data items of the reference subset in the reference initial states to the reference data items of the reference transformed state based on one or more characteristics of the reference data items.

12. The system of claim 11, wherein the one or more characteristics include (1) a color characteristic and (2) at least one of a movement characteristic or a distance characteristic.

13. The system of claim 1, the transformation rule is determined by inferring, via a machine-learning model, the goal attained by each one of the reference data items in the reference subset in transforming from the corresponding reference data items' reference initial state to the reference transformed state.

14. The system of claim 1, wherein the transforming of the candidate data items include moving a portion of the candidate data items from one location to another generating the candidate transformed state.

15. The system of claim 14, wherein the moving of the portion of the candidate data items includes moving a plurality of the candidate data items adjacent to a further candidate data item with minimal movement steps within a virtual two dimensional grid.

16. The system of claim 14, wherein the moving of the portion of the candidate data items includes moving a plurality of the candidate data items coincident with a further candidate data item with minimal movement steps within a virtual two dimensional grid.

17. The system of claim 1, wherein the transforming of the candidate data items include changing a portion of the candidate data items from one color to another color.

18. The system of claim 1, the identifying of the reference subset includes identifying a reference subset based on a first reference initial state and a first reference transformed state, and verifying the transformation rule causing the identification of the reference subset by applying the transformation rule to a second reference initial state causing the generation of a second reference transformed state, and comparing the second reference transformed state to a ground truth second reference transformed state.

19. A method comprising: accessing reference data that indicates reference initial states of reference data items and reference transformed states of the reference data items; identifying a reference subset of the reference data items with a transformation rule shared in common, the transformation rule defining a goal attained by each one of the reference data items in the reference subset by transforming from its reference initial state to its reference transformed state; accessing candidate data that indicates candidate initial states of candidate data items without indicating any transformed states of the candidate data items; identifying a candidate subset of the candidate data items based on the identified reference subset of the reference data items; transforming the candidate data items in the candidate subset from their candidate initial states to candidate transformed states based on the transformation rule that defines the goal attained by each one of the reference data items in the reference subset by transforming from its reference initial state to its reference transformed state; and generating an output that indicates the candidate transformed states of the candidate subset of the candidate data items, the transformed states of thecandidate subset attaining the goal defined by the transformation rule shared in common by the reference subset.

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 reference data that indicates reference initial states of reference data items and reference transformed states of the reference data items; identifying a reference subset of the reference data items with a transformation rule shared in common, the transformation rule defining a goal attained by each one of the reference data items in the reference subset by transforming from its reference initial state to its reference transformed state; accessing candidate data that indicates candidate initial states of candidate data items without indicating any transformed states of the candidate data items; identifying a candidate subset of the candidate data items based on the identified reference subset of the reference data items; transforming the candidate data items in the candidate subset from their candidate initial states to candidate transformed states based on the transformation rule that defines the goal attained by each one of the reference data items in the reference subset by transforming from its reference initial state to its reference transformed state; and generating an output that indicates the candidate transformed states of the candidate subset of the candidate data items, the transformed states of the candidate subset attaining the goal defined by the transformation rule shared in common by the reference subset.

Images