Object data store

Abstract

This publication describes systems and methods for storing object data. In some examples, the method includes generating a profile for an object in a catalog, the profile including a first feature vector corresponding to the object and a globally unique identifier (GUID) corresponding to the first feature vector in the profile; generating a search range that includes at least the GUID corresponding to the profile; generating a second feature vector from a live image scan; matching the second feature vector generated from the live image scan with the first feature vector using the generated search range; identifying the GUID corresponding to the first feature vector that matches the second feature vector; and outputting information corresponding to the object in the profile identified by the GUID, the GUID corresponding to the first feature vector.

Description

Background Technology

[0001] Traditional methods for object recognition, including facial recognition, involve creating groups, assigning and storing image data for those groups, training the system to learn from the image data, and cross-referencing new object images against the stored image data. These traditional methods present several challenges. First, because training data requires accurately cross-referencing new object images against the stored image data, traditional methods are time-consuming to execute, making them insufficient for real-time applications. Second, traditional methods cannot adequately handle the creation of new groups and / or the updating of current groups. For example, adding an object to a second group requires generating a completely new profile for the object and re-uploading the image data. Summary of the Invention

[0002] This summary is provided to introduce a set of concepts in a simplified form, which will be further described in the detailed embodiments below. This summary is not intended to identify key or essential features of the claimed subject matter, nor is it intended to be used as an aid in determining the scope of the claimed subject matter.

[0003] A computerized system and method for storing object data. In some examples, the method includes generating a profile for an object in a catalog, the profile including a first feature vector corresponding to the object and a globally unique identifier (GUID) corresponding to the first feature vector in the profile; generating a search range that includes at least the GUID corresponding to the profile; generating a second feature vector from a live image scan; matching the second feature vector generated from the live image scan with the first feature vector using the generated search range; identifying the GUID corresponding to the first feature vector that matches the second feature vector; and outputting information corresponding to the object in the profile identified by the GUID, the GUID corresponding to the first feature vector.

[0004] Other examples provide a system for storing object data. The system includes a processor and a computer-readable medium storing instructions that, when executed by the processor, are operable to cause the processor to generate a profile for an object in a directory, the profile including a first feature vector corresponding to the object and a globally unique identifier (GUID) corresponding to the first feature vector in the profile; generate a search range that includes at least the GUID corresponding to the profile; generate a second feature vector from a live image scan; match the second feature vector generated from the live image scan with the first feature vector using the generated search range; identify the GUID corresponding to the first feature vector that matches the second feature vector; and output information corresponding to the object in the profile identified by the GUID, the GUID corresponding to the first feature vector.

[0005] Other examples provide a method for retrieving stored object profiles. This method includes: receiving a live image scan from an electronic device; generating a feature vector from the live image scan; tagging the generated feature vector with a globally unique identifier (GUID); identifying a search scope within a directory that includes multiple partitions within the directory, wherein the directory includes object profiles, the profiles including information corresponding to the object and a stored GUID corresponding to the profile; searching in parallel within each of the multiple partitions for the stored GUID corresponding to the tagged GUID; and identifying the profile corresponding to the tagged GUID. Attached Figure Description

[0006] This specification will be better understood from the following detailed description, which is read with reference to the accompanying drawings, in which:

[0007] Figure 1 This is a block diagram illustrating an example of a system for object data storage according to this disclosure;

[0008] Figure 2 This is a block diagram illustrating a centralized registration data flow according to an example of this disclosure;

[0009] Figure 3 This is a computerized method for storing and retrieving biometric data, based on examples of this disclosure;

[0010] Figure 4 This is a block diagram illustrating an example of converting a table feature vector into a BLOB partition according to this disclosure;

[0011] Figure 5 This is a block diagram illustrating the creation and / or replacement of data according to examples of this disclosure;

[0012] Figure 6A This is a block diagram illustrating an example of adding an object to a catalog according to this disclosure;

[0013] Figure 6B This is a block diagram illustrating updating object profiles in a catalog according to an example of this disclosure;

[0014] Figure 6C This is a block diagram illustrating an example of implementing a profile within a search scope according to this disclosure;

[0015] Figure 6D This is a block diagram illustrating, according to an example of this disclosure, the identification of objects within a search scope;

[0016] Figure 7 It is a computerized method for object data storage and data streams according to the examples of this disclosure;

[0017] Figure 8It is a computerized method for storing object data and data streams according to various examples of this disclosure;

[0018] Figure 9 It is a computerized method for storing object data according to the examples of this disclosure;

[0019] Figure 10 This is a computerized method for retrieving a stored object profile, based on examples from this disclosure; and

[0020] Figure 11 This is a block diagram illustrating an example computing device for implementing examples of this disclosure.

[0021] Throughout the accompanying drawings, corresponding reference numerals denote corresponding parts. Figures 1 to 11 The system is shown as a schematic diagram. The accompanying drawings may not be drawn to scale. Detailed Implementation

[0022] This disclosure provides object data storage in a resilient catalog that enables real-time or near-real-time object recognition and labeling. By storing image data in a resilient catalog, the step of training data required by traditional object recognition methods is eliminated. Furthermore, virtually unlimited storage is provided by allowing horizontal scaling to meet demanding workloads while returning labeling results within seconds. The resilient catalog also allows searching by selecting object profiles from the catalog without needing to train objects or re-register objects into search groups. In other words, a database of object profiles can be maintained for searching, but only a subset of objects can be searched at a time.

[0023] In a specific example, this disclosure is implemented such that the object is an individual and the image data is facial data. For example, biometric storage stores facial data in a resilient catalog that supports real-time or near-real-time facial recognition identification. By storing facial image data in a resilient catalog, the step of training data required by traditional facial recognition methods is eliminated. Furthermore, virtually unlimited storage space is provided by allowing horizontal scaling to meet the required load while returning identification results within seconds. The resilient catalog also allows searching by selecting an individual's profile from the catalog without needing to train people or re-register people into the search group. In other words, a database of individual profiles can be maintained for searching, but only a subset of the objects can be searched at a time.

[0024] As mentioned above, the current solution can utilize the concept of objects, but these concepts are functionally limited. For example, the current solution essentially provides a container for uploading multiple images and calculating the average image feature vector, rather than a true object. Data within the container, such as image data, cannot be referenced or copied between groups. Therefore, new groups are needed to upgrade the group or to a new recognition model, and the training model needs to be invoked to reflect the new changes in the group. Furthermore, identity invocation can be blocked while training is in progress.

[0025] In existing solutions, the concept of an object is limited to a single group and cannot be shared across groups. Furthermore, the groups are typed. This presents several challenges because, advantageously, objects do not reside within a single group, groups do not need to be typed, and the creation of groups does not require the original image of the object. Therefore, the examples in this disclosure provide centralized profiles of objects in the storage layer, enabling groups to reference specific profiles and allowing the removal of typed groups.

[0026] Furthermore, in existing solutions, the training model must be called on large groups, i.e., Train(). For example, for face recognition, calling Train() allows a large group of people to calculate the average face of newly added faces and reflect changes to the production, while blocking the identification call. This prevents challenges because Train should not be needed at all, and alternatively, the identification call should not be blocked. Therefore, the example disclosed here enables the calculation of the average image as images are added, completely removing Train() and replacing it with eventual consistency, and preventing the identification call from being blocked.

[0027] Furthermore, in existing solutions, scalability is limited to one million objects or profiles in large object groups. This prevents challenges because some directories contain more than one million profiles and can reach sizes of twenty million or more. In some cases, directories are created containing images of objects that should be blocked, such as the faces of individuals who should be blocked from using a product or service. Therefore, the examples of this disclosure provide partitioning within the generated directories to accelerate identification, which enables parallelization of identification calls. This addresses the scalability limitations of current solutions by enhancing the scalability of image recognition (e.g., facial recognition) and data storage (e.g., biometric storage) as described in the examples of this disclosure.

[0028] Therefore, the system provided in this disclosure operates in an unconventional manner, organizing objects into smaller partitions within a flat list of registered individual profiles, making identification a mapping reduction operation that allows performance goals to be maintained. For example, in a facial recognition implementation, individuals can register in the system of this disclosure. These individuals are organized into smaller partitions within a flat list of registered individual profiles, making identification a mapping reduction operation that allows performance goals to be maintained. The registration and identification process tracks the size of each partition, the incremental additions and deletions of each partition, and repartitioning when partitions become too large or the increments of these partitions become too large. When repartitioning is performed, the uptime for identification and the uptime for administrative calls for adding / removing objects / images (e.g., people / faces) remain at 100% without performance loss. The profile catalog is designed around the object to be identified (e.g., a person) and supports binding multiple recognition models to the same underlying object. This disclosure allows multiple images of an object to be uploaded, for example from different angles, and calculates the best features to identify the object for each model. This disclosure further eliminates the need to create a new object catalog each time a new version of a recognition model is released.

[0029] Therefore, one aspect of this disclosure allows for a redesign of the storage of profiles for registered objects with centralized feature vectors within an Image API instance. For example, the registered object can be an individual, and the centralized feature vectors can be internal to the Face API instance. A globally unique identifier (GUID) is assigned to the individual's profile and used throughout the Face API instance. The GUID supports all existing and future recognition models. As described herein, explicit training is not required while maintaining a recognition performance Service Level Agreement (SLA) of three seconds or less.

[0030] Figure 1 This is a block diagram illustrating a system for storing object data, based on an example. Figure 1 The system 100 shown is for illustrative purposes only. Other examples of the system 100 may be used without departing from the scope of this disclosure.

[0031] System 100 includes computing device 102, network 132, and cloud server 134. Computing device 102 refers to any device that executes computer-executable instructions 106 (e.g., as an application, operating system function, or both) to implement operations and functions associated with computing device 102. In some examples, computing device 102 includes mobile computing devices or any other portable devices. Mobile computing devices include, but are not limited to, mobile phones, laptop computers, tablet computers, computing boards, netbooks, gaming devices, and / or portable media players. Computing device 102 may also include less portable devices such as servers, desktop personal computers, kiosks, or desktop devices. Furthermore, computing device 102 may represent a set of processing units or other computing devices.

[0032] In some examples, computing device 102 includes at least one processor 108, memory 104 including computer-executable instructions 106, and user interface device 110. Processor 108 includes any number of processing units and is programmed to execute the computer-executable instructions 106. The computer-executable instructions 106 are executed by processor 108, by multiple processors within computing device 102, or by a processor external to computing device 102. In some examples, processor 108 is programmed to execute the computer-executable instructions 106, such as those shown in the figures described herein, for example... Figures 2 to 11 In various examples, processor 108 is configured to execute one or more of the following: sensor(s) 114, partitioning component 122, object recognition module 118, machine learning model 120, and catalog generation component 116.

[0033] Memory 104 includes any number of media associated with or accessible by computing device 102. In these examples, memory 104 is located within computing device 102, such as... Figure 1 As shown. In other examples, memory 104 is located external to computing device 102 or both internal and external to computing device 102. For example, memory 104 may include memory components internal to computing device 102 and memory components external to computing device 102. Memory 104 stores data, such as one or more applications. When executed by processor 108, the applications operate to perform various functions on computing device 102. Applications may communicate with corresponding applications or services, such as network services accessible via network 132. In one example, the application represents a client-side application corresponding to a server-side service downloaded in a cloud such as cloud server 134.

[0034] User interface device 110 includes a graphics card for displaying data to and receiving data from a user. User interface device 110 may also include computer-executable instructions, such as a driver, for operating the graphics card. Furthermore, user interface device 110 may include a display, such as a touchscreen display or a natural user interface, and / or computer-executable instructions, such as a driver, for operating the display. User interface device 110 may also include one or more of the following for providing data to or receiving data from a user: a speaker, a sound card, a camera, a microphone, a vibration motor, one or more accelerometers, etc. The device includes a brand communication module, global positioning system (GPS) hardware, and a photosensitive light sensor. In a non-limiting example, the user inputs commands or manipulates data by moving the computing device 102 in one or more ways.

[0035] Computing device 102 also includes a communication interface device 112. Communication interface device 112 includes a network interface card for operating a network interface card and / or computer-executable instructions such as drivers. Communication between computing device 102 and other devices such as, but not limited to, cloud server 134 can occur over any wired or wireless connection using any protocol or mechanism. In some examples, communication interface device 112 may operate using short-range communication technologies such as those using near-field communication (NFC) tags.

[0036] The computing device 102 also includes a data storage device 124 for storing data, such as, but not limited to, data 128. Data 128 may be a catalog of profiles generated by the catalog generation component 116. In some non-limiting examples, the data storage device 124 includes a redundant array of independent disks (RAID).

[0037] In this example, data storage device 124 is included within, attached to, inserted into, or otherwise associated with computing device 102. In other examples, data storage device 126 includes remote data storage accessed by computing device 102 via network 132, such as a remote data storage device, data storage in a remote data center, or cloud storage.

[0038] Computing device 102 includes one or more sensors 114 configured to capture image data. In some examples, the captured image data is facial image data of an individual's face. The one or more sensors 114 may include one or more cameras, such as red, green, and blue (RGB) cameras, infrared (IR) cameras, etc. Computing device 102 also includes a catalog generation component 116 configured to generate a catalog of profiles. Each profile in the catalog includes a feature vector as an average of image data scans (such as live image scans) and a globally unique identifier (GUID) corresponding to the profile. For example, in a biometrics repository for facial data implemented in system 100, each profile in the catalog includes a feature vector as an average of live image scans (such as live facial scans in the biometrics repository example) and a GUID corresponding to the profile. The computing device 102 also includes a partitioning component 122 configured to partition the catalog generated by the catalog generation component 116 into multiple partitions that can be searched in parallel to identify GUIDs in the catalog corresponding to live image scans obtained by one or more sensors 114, as described in more detail below. The computing device 102 also includes an object recognition module 118 that identifies objects in the acquired live image scans and generates feature vectors. In an example where the system 100 is implemented for face recognition, the object recognition module 118 is implemented as a face recognition module that identifies faces in the live image scan data and generates feature vectors. The computing device 102 also includes a machine learning model 120 to optimize the parallel search of the partitions.

[0039] Figure 2 This is a block diagram illustrating a centralized registration data flow according to an example of this disclosure. Figure 2 The block diagram 200 is for illustrative purposes only and should not be construed as limiting. Various examples of the block diagram may be used without departing from the scope of this disclosure.

[0040] A registration database 210 is generated, which stores profiles for each object. In some examples, the registration database 210 is a directory containing profiles for each object. In the registration database 210, one or more images, such as identification_01 feature vectors and identification_02 feature vectors, are analyzed to generate feature vectors for the objects, which are then input into a file containing the object's profile in the directory. The feature vector is the average of all the results from the image data and is specific to each individual. In some examples, live image scanning is used to capture the images. Specific scenes are stored in the file containing the object's profile in the directory, such as IR_Physical_Access indicating how each feature vector was captured. Using the feature vector data and scene data, a GUID is assigned to the object. A GUID is a pointer or label to a specific list (i.e., profile) of objects in the directory. In some examples, a GUID is an identifier consisting of a combination of numbers and alphanumeric characters. For example, each position of the GUID may include either alphanumeric letters AF or the numbers 0-9. Example GUIDs could be “d44651f-fadb-41f5-8918-c3060996448”, “c1d36745-2548-4abf-b057-2386c96d52f”, etc.

[0041] In some examples, registration database 210 stores the profile of each individual who has opted to join the registration. Registration database 210 includes the profile of each individual. One or more images, such as Recognition_01 facial feature vector and Recognition_02 facial feature vector, are analyzed to generate the individual's facial feature vector, which is then input into a file containing the individual's profile in a directory.

[0042] A search scope 220 is generated that defines a specific profile group. In some examples, search scope 220 is referred to as a dynamic group. Search scope 220 is a container that defines a specific group of objects, whose profiles are stored in a directory by including the permanent object ID of each object to be included in search scope 220. In some examples, the permanent object ID of each object is a GUID. In some examples, the GUID corresponding to an object is included in multiple search scopes 220. For example, Figure 2The computerized method can be implemented in airports for facial recognition. In this example, a single individual's GUID is included in a first search scope targeting a security checkpoint and a second search scope targeting a specific flight. The first search scope targeting a security checkpoint can include all profiles of individuals who purchased tickets for flights on a specific date, while the second search scope targeting a specific flight only includes profiles of individuals who purchased tickets for the specific flight indicated by the second search scope. Search scope 220 is updated to add or remove individual profiles from the search space. Search scope 220 and user data are stored until the search scope is deleted. In some examples, search scope 220 is stored until it is manually deleted. In other examples, search scope 220 is stored for a period of time, such as one day, one week, one month, etc., and deleted when that period of time is met.

[0043] A detection call 230 is received, which includes image data and a recognition model. In some examples, the image data is a facial image to be recognized. In some examples, the recognition model refers to a specific model used to recognize the object. The recognition model may include scene data involving which quality filter is applied, such as red, green, blue (RGB), infrared (IR), etc. In other words, the detection call 230 is associated with a specific recognition model that provides feature vectors of the image data.

[0044] An identification call 240 is provided, which includes a search range and feature vectors of image data from a detection call. In other words, the identification call identifies the feature vectors of the image data and the range to search for those feature vectors. In the example above, the search range could be a second search range identifying a list of passengers who have purchased tickets for a specific flight, and the feature vectors of the facial image data are the feature vectors of individuals attempting to board a specific flight. The identification call loads facial feature vectors from a directory matching search range 220 and compares the feature vectors from the detection call with each GUID pulled from the directory and included in the search range. Examples of this disclosure allow for parallel comparisons, where multiple objects are independently identified as part of the same request, such as multiple live image scans received at the same time or nearly simultaneously, like a live facial scan in a biometrics example.

[0045] Potential matches between the feature vectors of the live data and the feature vectors of the GUIDs included in the search scope 220 are identified by calculating the similarity between the feature vectors of the live data and the feature vectors of the GUIDs. One or more candidate objects corresponding to the identified GUIDs are retrieved, and information from the original raw data stored in the catalog is returned in order of similarity confidence. When a potential match for the feature vectors of image data is identified, a confidence level for that match is provided to the data corresponding to the profiles of the matching objects in the catalog. For example, using the example above, the feature vectors corresponding to the image data of passengers are compared with the feature vectors of the GUIDs in the search scope 220 to identify potential matches, and a confidence level for the name and seat information of the potential matches is provided. In some examples, the computerized method includes verification to determine whether two images belong to the same object or two different objects.

[0046] In some examples, the number of candidate objects is limited or restricted by a predetermined maximum number of candidates to be returned and a confidence threshold. For example, a predetermined maximum number of candidates to be returned limits the number of candidates returned. Therefore, only the candidate with the highest confidence within the limit will be returned. The confidence threshold specifies the minimum confidence required to return a result as a potential candidate. In some examples, no potential candidates are identified within the search range 220. In these examples, an empty array will be returned along with an error message indicating that no potential candidates were identified.

[0047] Figure 3 This is a computerized method for storing and retrieving biometric data, based on examples of this disclosure. Various examples of the computerized method 300 can be used without departing from the scope of this disclosure.

[0048] It should be understood that Figure 3 The example method 300 presented is for illustrative purposes only and should not be construed as limiting. In other words, although... Figure 3 This disclosure is illustrated in a facial recognition system for storing and returning biometric data; however, this disclosure can be implemented in any suitable type of object recognition system for storing and returning object data described herein. The computerized method 300 is implemented by one or more components described herein, such as computing device 102.

[0049] The computerized method 300 begins in operation 301 with the registration of individuals into a directory via directory generation component 116. The capacity of this directory is virtually unlimited. For example, the directory could store over 75 million identities, but this number is only limited by the pricing model. In fact, this limitation is unlimited because the directory is designed to scale horizontally to meet the required load while returning identification results within seconds. In operation 303, facial image data is obtained. In some examples, facial image data is obtained via live facial scanning by a camera. The camera can be any camera suitable for capturing facial image data, such as an RGB camera, an infrared camera, etc.

[0050] In operation 305, the object recognition module 118 generates a feature vector for the captured facial image data and stores it in a directory. Storing the feature vector along with personal information such as name and contact information in the directory allows for later identification of an individual's profile using facial recognition without storing the facial image data itself in the directory. In other words, the facial image data can be discarded after the feature vector is generated and stored. Therefore, storage requirements are reduced because the original image data is no longer needed and can be discarded, and security is enhanced by maintaining less data for each individual.

[0051] In operation 307, the partitioning component 122 tagged an individual's profile in the directory with a GUID. In some examples, the GUID is a pointer that can be used to a specific profile stored in the directory. Because the GUID is used as a pointer and stored along with the individual's feature vector, latency is reduced when identifying the individual later based on facial image data. In operation 309, the partitioning component 122 added the GUID to one or more search scopes. For example, in the example above, a single GUID was included in a first search scope targeting security checkpoints and a second search scope targeting a specific flight. Instead of generating new profiles for individuals to be included in each individual search scope, the GUID in the directory can be used in multiple search scopes.

[0052] In operation 311, data from a live facial scan is received via object recognition module 118. In the example above, facial data of an individual is obtained via a live facial scan when the individual boards a flight for which they have purchased a ticket. In operation 313, object recognition module 118 performs facial recognition to generate a feature vector of the facial data. The generated feature vector of the facial data is compared with a GUID included in the search scope.

[0053] In operation 315, processor 108 identifies a match between the feature vector of the generated facial data and a GUID pulled from a catalog and included in the search scope. In operation 317, based on the identified match, processor 108 controls the return of the result. In some examples, the result is returned via user interface device 110 or sent over network 132 via communication interface device 112. In some examples, the result includes the match and the confidence level of the match. In some examples, the result also includes some or all of the details stored in the profile associated with the GUID, such as the name, contact information, etc. of the individual matching the facial data. As described herein, the GUID is placed immediately next to the specific data, rather than pointing to a separate lookup table that must be searched subsequently, thus reducing latency and providing results significantly faster than current solutions.

[0054] As described above, method 300 is for illustrative purposes only and should not be construed as limiting. For example, method 300 could be implemented to identify matches of objects that are not faces. In these examples, non-human objects are registered in a catalog, image data is obtained, a feature vector is generated and stored for the object, and the object is labeled with a GUID added to one or more search ranges. After receiving a live image scan of the object, object recognition is performed to generate a feature vector from the image data received from the live image scan. Matches of the feature vector from the live image scan with the GUIDs included in the search ranges are identified, and the results are returned.

[0055] Some examples in this disclosure consider the quality of raw live image scans received during personal registration. For example, low-quality live image scans may distort the feature vectors corresponding to the GUIDs used in the profiles for object identification and will therefore be avoided. Thus, some examples include quality filters that reject certain images based on image pose, lighting, etc. In some examples, the same quality filter is used when adding images to an object's profile. Therefore, the scene is used to determine which quality filter to apply, and then the feature vectors matching the use case are saved. Thus, the recognition model is removed from the methods for adding and detecting images described herein. By knowing the provided image type and scene, all models for a specific scene can be computed in parallel. Various scenes can include physically accessed RGB, physically accessed IR, physically accessed arbitrary, and physically accessed all. In some examples, the scene includes a list of scene versions. Given a scene, all scene versions can be computed in parallel, and the feature vectors of a given scene version can be examined. The results are then combined based on the highest confidence score. In some examples, each scene version includes fields such as a detection model, a quality filter, and a recognition model.

[0056] In some examples, this disclosure allows images to be added to a profile in an object data store for identification or verification. For example, the image could be a facial image, and the object data store could be a biometric store. To process an image containing multiple objects, the input object can be specified as an image with a targetObject rectangle. It returns a persistedImageId representing the added image. No image is stored. Only the extracted features(s) are stored on the server until Object Image-Delete, Object-Delete is called. In some examples, features are stored until manually deleted. In other examples, features are stored for a period of time, such as a day, a week, a month, etc., and deleted when that period is met. In some examples, features are deleted from an individual's profile. In other examples, the entire profile of an individual is deleted. In the case of deleting the entire profile, all information included in the profile, such as PersistedImageID or PersistedFaceID, user data, image feature data such as facial feature data, etc., is deleted.

[0057] Adding / removing images to / from the same object will be processed sequentially, while adding / removing images to / from different objects will be processed in parallel. Operation location can be used to determine when image changes are reflected in the overall service production. Adding an image to an object takes some time to be reflected in the identification call. Each object can have up to 248 images for each identification type.

[0058] As described in this article, low-quality images should be avoided, and higher-quality images should be preferred. Higher image quality leads to more accurate recognition. For example, in biometric implementations, high-quality facial images include frontal, clear faces with a size of 200x200 pixels, such as 100 pixels between the eyes, or larger. In some examples, the minimum detectable face size is 36x36 pixels in images no larger than 1920x1080 pixels. Images larger than 1920x1080 pixels may require a proportionally larger minimum face size. In some examples, different detection model values ​​are provided. For example, detection_01 could be the default detection model for large groups of people added to images (e.g., faces), while detection_02 could be a newer detection model that includes improved accuracy, particularly on small, side-view, and blurred images (e.g., faces).

[0059] Adding an image to a scene object's profile requires successfully processing images from multiple scene version pipelines, as feature vectors from the latest production and flight scene versions are stored in case of detection failures or the need for rollback. In some examples, an image will not be added to an object's profile if a previous scene version did not pass through any previous pipelines. In other words, for an image to be added and detected, the incoming image must pass through all pipelines to ensure that every object in each search group is always considered in every identification call. In some examples, some scene versions are disabled.

[0060] In some examples, adding an image to an object's profile requires verifying the object's identity during registration. For instance, when the object is a person, additional authentication methods can be used to manually verify a live image scan of the person's face, such as comparing it to a driver's license photo, passport photo, previous facial image data stored in the personal profile, or other biometric data.

[0061] In some examples, adding an image includes an operation location that stores the feature vector corresponding to that image. The operation location is used to determine when to perform and / or reflect image changes throughout the service product.

[0062] Some examples of this disclosure include serialization / deserialization methods to improve performance. Some examples of this disclosure include reverse search range lookup methods. When an object's profile is added to a group, the search groups to which that individual's profile has been added are also saved. Saving the search groups enables the reverse lookup method to return results that include each search range, each search range including a specific GUID for the individual's profile.

[0063] In some examples, the directory storing profiles containing data for each object is called a centralized directory, such as registry database 210. By centralizing the data in a single directory, a search is performed by referencing only one copy. Dereferencing these references (i.e., pointers) when removed from memory is costly. In memory, dereferencing is fast, but when removed from the local computer, another computer (i.e., the database layer) must be introduced to communicate with the original computer. However, in this disclosure, individuals in a single centralized directory can be referenced in any number of search ranges because the search is performed in parallel with the centralized references. In some examples, the feature vector of each registered object is maintained in a pre-aggregated binary large object (BLOB) based on a partitioning of the recognition model type. In some examples, the BLOB is a cached version in memory of registry database 210, which is described in more detail above. For example, the original NIST facial feature vector is 1024 bytes, or 256 floating-point numbers.

[0064] As described herein, various examples of this disclosure eliminate the need for training data. Traditional training methods compute an average image based on all images of a specific object in a database. Aspects of this disclosure eliminate the need for training by updating the average image (i.e., the feature vector) when a new image is added to the catalog. By implementing cloud storage, it becomes possible to obtain all images of an object profile in a single read, compute and write back feature vectors in parallel for multiple images, and eliminate the need for locking. In some examples, calls to objects can be serialized, or batch image uploads can be received to further enhance aspects of this disclosure. Furthermore, an explicit `Train()` function is not required. Instead, eventual consistency provides identification / grouping performance.

[0065] For example, the database is updated to include new data, such as profiles of new objects and / or new image data for existing objects. Messages are placed in a queue to update the intermediate / cache layer. The intermediate / cache layer is updated using extreme operations. To delete an object or update its profile, the location where the object's feature vector is saved or stored in the intermediate page BLOB must be known. This is aided by the use of partitioning, as described in more detail below.

[0066] Figure 4 A block diagram illustrating the conversion of a table feature vector into a BLOB partition, according to an example of this disclosure, is shown. Figure 4 Block diagram 400 is for illustrative purposes only and should not be construed as limiting. Various examples of block diagram 400 may be used without departing from the scope of this disclosure.

[0067] like Figure 4 As shown, the database flat list is divided into multiple partitions based on the range and / or number of object IDs. In some examples, the range of object IDs is a lexicographical range. In some examples, Figure 4 The table entity shown is an Azure table entity that stores the partition key, object ID, up to 248 images, and the average image as a feature vector. Any changes to the table entity are merged into the registered object print BLOB, and the changes are stored in the increment of the registered object print BLOB.

[0068] In some examples, partitions are created by reading a first EnrolledObjectPrintBLOB followed by a smaller second EnrolledObjectPrintBLOB. For example, the second EnrolledObjectPrintBLOB is at least an order of magnitude smaller than the first EnrolledObjectPrintBLOB. In some examples, the first EnrolledObjectPrintBLOB can be as large as several megabytes. Because the first EnrolledObjectPrintBLOB is larger, caching the file takes less time than caching the file in a larger BLOB, since there are relatively fewer changes in the larger first EnrolledObjectPrintBLOB. Furthermore, the smaller size of the second EnrolledObjectPrintBLOB reduces the time required to read and write to it. In other words, because the second EnrolledObjectPrintBLOB is smaller, reading the smaller second EnrolledObjectPrintBLOB, adding and / or removing one or more prints, and writing new or updated second EnrolledObjectPrintBLOBs takes less time. The time required to read and process the file is linearly related to the file size, so the second EnrolledObjectPrintBLOB remains within a manageable size, such as within a few kilobytes, to maintain performance. Therefore, in some examples, changes are written to the second EnrolledObjectPrintBLOB, but not to the first EnrolledObjectPrintBLOB.

[0069] Figure 5 Block diagrams illustrating various examples of creating and / or replacing data according to this disclosure are shown. Figure 5 The block diagram 500 is for illustrative purposes only and should not be construed as limiting. Various examples of the block diagram 500 may be used without departing from the scope of this disclosure.

[0070] In some examples, block diagram 500 will increment the BLOB (such as...) Figure 4 The incremental BLOB shown is merged into a larger BLOB. In some examples, block diagram 500 uses additional bits to change the number of partitions. In some examples, the creation and / or replacement of partitions are performed in parallel, for example, due to the use of lexicographical searches.

[0071] Figure 5The table entity showing the registered objects includes partition keys, object IDs, up to 248 images, and the average image as a feature vector. Current and newer versions of the BLOB, categorized by the recognition model, are also provided. Figure 4 As shown and described. At box 510, the worker nodes are repartitioned, and the new version of the BLOB is swapped with the current version. (See diagram / description.) Figure 5 As shown, the BLOBs of the registered objects in the new version are created directly from databases such as database 210.

[0072] At box 520, a BLOB is created and a lease is acquired. This effectively creates a lock, and all new changes will be written to this lock. At box 530, messages are processed for registered message queue workers. For example, a message could be used to generate an increment of the registered worker's printed BLOB. In the example of acquiring an updated lease, a new version of the registered worker's printed BLOB increment is updated.

[0073] In some examples, the partition size becomes too large to maintain performance standards. For instance, the second EnrolledObjectPrintBLOB of the partition is too large. In this example, a new instance of the partition is created, and the second EnrolledObjectPrintBLOB is merged into the first EnrolledObjectPrintBLOB. Since this process can sometimes take time, changes made during the merge are written to both the existing second EnrolledObjectPrintBLOB and the new instance of the partition. Once the new instance of the first EnrolledObjectPrintBLOB is complete, the active partition is updated, making the new instance of the first EnrolledObjectPrintBLOB the active partition and maintaining performance.

[0074] Figure 6A This is a block diagram illustrating the addition of an object to a catalog according to an example of this disclosure. Block diagram 601 is presented for illustration only and should not be construed as limiting. Various examples of block diagram 601 can be used without departing from the scope of this disclosure. Block diagram 601 is implemented by one or more components described herein, such as computing device 102.

[0075] Specifically, Figure 6AA block diagram 601 illustrates the process of adding an object to a directory, such as database 210. As described herein, in some examples, the object is a person, and a new profile for that person is created in the directory. The Image API is called into the interface. A key-value table, such as an Azure table, is accessed, and the new object is created. A new GUID is created, and additional data about the object is added. The additional data includes other information about the object, such as identification information. In the example where the object is a person, the additional data may include a phone number and an email address. The new object is placed in a queue to update the BLOB increment, and a message indicating the presence of a new object in the queue is sent to notify the worker role of the queue's status.

[0076] The worker role selects the object from among other new objects to update the BLOB increment. In other words, it creates and batches more than one new object to update the BLOB increment within a partition simultaneously, rather than updating the partition with a single new object. For example, because the identity call is performed on a partition-by-partition basis, updates to partitions are ideally performed less frequently, as the cache is invalidated while the update is being performed. In some examples, a maximum number of updates can be performed at once to maximize update resources while minimizing cache invalidation. For example, a maximum of 1000 objects might be added from the queue at a time.

[0077] A partition log is maintained, identifying each partition and the data stored within it as up-to-date. In some examples, multiple partitions point to the same data due to the size of the incremental BLOB. When a partition's incremental BLOB becomes too large, a new partition is created, and the increment is merged into the new partition. All new changes are then merged into the new partition file. When an identification call is performed on a partition, the latest partition is identified and searched for due to potential delays in merging or combining each redundant partition file. In other words, added objects are only written to the incremental BLOB file and then used to update the partition.

[0078] Figure 6B This is a block diagram illustrating updating object profiles in a catalog according to an example of this disclosure. Block diagram 603 is presented for illustration only and should not be construed as limiting. Various examples of block diagram 603 can be used without departing from the scope of this disclosure. Block diagram 603 is implemented by one or more components described herein, such as computing device 102.

[0079] Specifically, Figure 6BA block diagram 603 illustrates a process for adding images to the profiles of objects in a directory such as database 210. In the example where the object is a person, the image added to the profile is a face. In some examples, the process of adding an image to an object is similar to creating an object. A list of existing objects is compared to a list of feature vectors, allowing the use of multiple types of recognition models. This allows for easy updating or deleting of objects. For example, to add an image, the feature vectors are added to an existing object profile by updating an incremental BLOB from a queue, which is updated at intervals, thus avoiding unnecessary invalidation of the cache. When deleting an object or removing an image included in a profile, the process allows the profile to be deleted one at a time from each partition that includes it, rather than deleting the profile individually from each partition.

[0080] Figure 6C This is a block diagram illustrating an example of implementing the profile within the scope of this disclosure. Block diagram 605 is presented for illustration only and should not be construed as limiting. Various examples of block diagram 605 can be used without departing from the scope of this disclosure. Block diagram 605 is implemented by one or more components described herein, such as computing device 102.

[0081] Specifically, Figure 6C A block diagram 605 is shown for including specific profiles from a directory such as database 210 within a search scope. Figure 6C As shown, the Image API obtains a valid list of ObjectsIDs from IEnrolledObjectDB. ISearchScopeDB executes the Image API to add the GUIDs to the search scope BLOB. In some examples, block diagram 605 illustrates adding the GUIDs to the search, as described in more detail above with respect to operation 309.

[0082] Figure 6D This is a block diagram illustrating an example of identifying objects within a search scope according to the present disclosure. Block diagram 607 is presented for illustration only and should not be construed as limiting. Various examples of block diagram 607 can be used without departing from the scope of this disclosure. Block diagram 607 is implemented by one or more components described herein, such as computing device 102.

[0083] In some examples, the database 210 flat list (i.e., directory) is divided into multiple partitions based on the lexicographical scope and / or number of partitions of an object or individual's identifier (e.g., GUID). Partitions can then be searched directly from the directory. In some examples, the search for each partition is distributed in parallel to support a larger search scope while maintaining low latency. For example, partitions can be searched and matching feature vectors extracted, allowing feature vectors to be cached for faster search scope requirements during repeated calls. In other words, parallel searching of each partition, rather than searching the entire directory, maintains low latency due to parallelized / distributed searching. Therefore, underground searches can be performed by caching BLOBs on nodes, eliminating the need to retrieve cloud database BLOBs for each request. In some examples, a content-aware load balancer can be leveraged to pass requests from the front end to the back end, and stickiness can be achieved by allowing worker nodes to reconnect to backend worker nodes that have previously searched and / or worked on that partition and still have data in storage, based on unique partition tokens. In some examples, the initial search scope is improved through distributed mapping / simplified queries to reduce the size of each search field. Incremental addition / deletion further allows for faster addition and deletion of personal profiles to the search scope, which in turn allows caching of a large number of individuals listed in the search scope.

[0084] Figure 7 This is a computerized method for storing and streaming object data according to various examples of this disclosure. The computerized method 700 is presented for illustrative purposes only and should not be construed as limiting. Various examples of the computerized method 700 can be used without departing from the scope of this disclosure. The computerized method 700 is implemented by one or more components described herein, such as computing device 102.

[0085] The computerized method 700 begins with the service of the client performing an identification action in operation 701. The identification operation searches for results in a directory such as database 210. In some examples, the result is a specific profile of an object stored in the database. In operation 703, a cache (e.g., a Redis cache) retrieves a cached list of image features from the search space. In some examples, the feature list is...<GUID,byte[]> The format is provided. In some examples, the key-value pair is group name + training ID. In operation 705, for example, the storage device of data storage device 124 searches the BLOB for the group, group name, and training ID retrieved from the cache. In operation 707, the service identifies the cached and stored results. In some examples, the results indicate objects corresponding to GUIDs. In operation 709, the identified results are output. In some examples, the identified results are output to a user interface device. In some examples, the identified results are output to an external device via network 132.

[0086] Figure 8 This is a computerized method for storing and streaming object data according to various examples of this disclosure. The computerized method 800 is presented for illustrative purposes only and should not be construed as limiting. Various examples of the computerized method 800 can be used without departing from the scope of this disclosure. The computerized method 800 is implemented by one or more components described herein, such as computing device 102.

[0087] The computerized method 800 begins with an operation 801 identifying a client service performing a group-adding action. The identification operation identifies the object to be added to the group, such as a search range. In operation 803, a database layer (such as database 210) adds the object to the specific group. In some examples, adding an object to a specific group involves adding the object to a specific partition within database 210. In operation 805, a storage device (such as data storage device 124) updates the BLOB to include the added object in the group. For example, the storage device updates the group, group name, and training ID to include the newly added object. In operation 807, a cache (such as a Redis cache) updates its search space to include the updated BLOB. In operation 809, the service identifies or confirms the group-adding result, indicating that the added object has been added to the group. In operation 811, the result is output. In some examples, the result is output to a user interface device. In some examples, the result is output to an external device via network 132.

[0088] Figure 9 This is a computerized method for storing object data according to various examples of this disclosure. The computerized method 900 is presented for illustrative purposes only and should not be construed as limiting. Various examples of the computerized method 900 can be used without departing from the scope of this disclosure. The computerized method 900 is implemented by one or more components described herein, such as computing device 102.

[0089] Method 900 begins in operation 901, where computing device 102 generates a profile for an object in a catalog. In some examples, the catalog is a database, such as database 210. The profile includes a first feature vector corresponding to the object and a globally unique identifier (GUID) corresponding to the first feature vector in the profile. In some examples, the first feature vector is generated by obtaining raw image data corresponding to the object and generating the first feature vector corresponding to the object based on the obtained raw image data.

[0090] In some examples, computing device 102 generates multiple partitions within the directory. The profile generated for the object is categorized into one or more of the generated partitions.

[0091] In operation 903, computing device 102 generates a search scope. The search scope includes at least a GUID corresponding to a profile. In some examples, the search scope includes multiple GUIDs, each corresponding to a separate profile. In other words, the search scope identifies the object to be searched, and the object is identified by its corresponding GUID. In some examples, the generated search scope includes multiple partitions.

[0092] In operation 905, computing device 102 generates a second feature vector from a live image scan. In some examples, computing device 102 performs an object recognition application to generate the second feature vector. It should be understood that, as used herein, the terms "first" feature vector and "second" feature vector are used only to distinguish between a feature vector corresponding to a stored object profile and a feature vector generated from a live image scan. The first feature vector may also be referred to as the original feature vector, the stored object feature vector, etc. The second feature vector may also be referred to as the live image scan feature vector.

[0093] In some examples, a second search range is generated that includes a GUID corresponding to the profile. In other words, a single GUID corresponding to the profile can be included in multiple search ranges that are executed in parallel or substantially simultaneously, in order to improve the time required to match the generated second feature vector with the first feature vector.

[0094] In operation 907, computing device 102 uses the generated search range to match the second feature vector generated from the live image scan with the first feature vector. In other words, the second feature vector generated from the live image scan is matched with the first feature vector stored in a catalog.

[0095] In operation 909, computing device 102 identifies a GUID corresponding to a first feature vector that matches the second feature vector. In other words, the GUID points to a specific profile of an object that matches the second feature vector based on the matching of its feature vector. In doing so, objects stored in a catalog are identified as matching objects from which a live image scan is obtained.

[0096] In operation 911, computing device 102 outputs information corresponding to an object identified by a GUID as a profile corresponding to a first feature vector. In some examples, the information is output to a user interface, such as user interface device 110. In some examples, the information is output to an external device via network 132.

[0097] In some examples, the objects stored in the catalog are individuals, i.e., people, and the live image scan is a live facial scan. In this example, the information output in Operation 911 is information about the individual, such as contact information, date of birth, etc.

[0098] Figure 10 This is a computerized method for retrieving a stored object profile, based on various examples of this disclosure. The computerized method 1000 is presented for illustrative purposes only and should not be construed as limiting. Various examples of the computerized method 1000 can be used without departing from the scope of this disclosure. The computerized method 1000 is implemented by one or more components described herein, such as computing device 102.

[0099] Method 1000 begins in operation 1001, where computing device 102 receives a live image scan from an electronic device such as a camera. The live image scan provides scanned and image data of an object. In operation 1003, computing device 102 generates a feature vector from the live image scan. In operation 1005, computing device 102 identifies the generated feature vector with a globally unique identifier (GUID).

[0100] In operation 1007, computing device 102 identifies a search scope within the directory. In some examples, the directory is a database such as database 210. The search scope includes multiple partitions within the directory. The directory includes profiles of objects, which include information corresponding to the object and a stored GUID corresponding to the profile.

[0101] In operation 1009, computing device 102 searches in parallel for the stored GUID corresponding to the marked GUID in each of the multiple partitions. In operation 1011, computing device 102 identifies profiles in the directory corresponding to the marked GUID. Once a profile is identified, computing device 102 can perform various operations. In some examples, computing device 102 modifies information in the identified object profile. In some examples, computing device 102 deletes information in the identified object profile. In some examples, computing device 102 deletes the identified object profile.

[0102] As described herein, the database layer is implemented as a centralized directory with no limit on the number of personal profiles that can be added. The database layer includes multiple field names, including partition key, row key, GUID, person ID such as name, user data such as contact information, and groups such as all groups referencing that ID. The database layer stores feature vectors of objects, such as feature vectors corresponding to received image data. In some examples, the object is a face, the feature vector is a facial feature vector, and the received image data is received facial image data. In some examples, the directory is limited to 248 feature vectors per recognition model type and includes multiple field names, including partition key, row key, feature vector, average image of feature vectors such as those described herein, and image number, which can contain up to 248 columns, each corresponding to a separate feature vector. In some examples, the database layer stores which objects recently have updated feature vectors and require updates to their groups. In these examples, various field names include partition key, row key, feature vector, groups such as groups to be updated, and completed groups such as groups that have been updated. The search group within the database layer includes field names, which include partition keys, row keys, GUIDs, and is deleted, indicating when an object was deleted (which can be nullable).

[0103] Various examples disclosed herein include options for creating profiles of objects within a database, deleting profiles of objects within a database, adding profiles to groups, removing profiles from groups, adding or deleting feature vectors of profiles, and identifying objects based on live image scans. For example, to create a personal profile, the system assigns a new GUID to the individual. The system checks to ensure the GUID is unique and does not conflict with another GUID and / or profile of an existing object in the system. Information about the object, such as feature vectors, GUID, contact information if the object is an individual, etc., is entered, and the new profile for the object is submitted. To delete a profile, the isDeleted field is updated to the specific date and time the profile is to be deleted, and all groups are moved to a folder to be deleted. To add a profile to a group, each object GUID and group ID (e.g., group GUID) is identified and cross-referenced to confirm that the profile is not yet included in the group. The object GUID is then written to the group GUID using ETag, and the cache is updated. To remove a profile from a group, each object GUID and group ID (e.g., group GUID) is identified and cross-referenced to confirm that the profile is included in the group. Then, the object GUID is removed from the group GUID, and the cache is updated. To add a feature vector to a profile, the object GUID is called, the feature vector is added to the table, and the process is committed. To remove a feature vector from a profile, the object GUID is called, the feature vector is removed from the table, and the process is committed. To identify objects based on a live image scan, live image data from the live image scan is obtained, the cache used for the search range group is loaded, comparisons are performed against the loaded data, the actual data is loaded for near-matching, and the results and their confidence levels are returned.

[0104] In some examples, the various options described herein can be executed in parallel, that is, substantially simultaneously. For example, image data added and / or deleted from different profiles can be processed and executed in parallel. As another example, image data for adding and / or deleting individuals from the same profile can be processed and executed sequentially and immediately. In other words, the processing of the second image data begins as soon as the processing of the first image data is completed.

[0105] In some examples, the database stores object data in a table that includes object ID, feature vector, identification model type, any data regarding scheduled soft deletion of personal data, and, in the case of an object being a person, user-provided information such as contact information and metadata. A separate table is provided for each profile storing the data. Object data may be stored in a list of group claims and / or intermediate storage, for example, when group data is scheduled for updates. In some examples, the database includes a search scope, which is a rapid group creation process hydrated from a cached data structure storage database.

[0106] The various examples disclosed herein utilize one or more BLOBs, as described herein. The BLOB page layout includes the object's GUID and original feature vector. Some examples also include temporary incremental BLOBs to avoid requiring a full rehydration. Options for adding profiles, deleting profiles, and updating profile images can first update the incremental BLOB, and once the limit is reached, a full refresh is initiated.

[0107] Some examples of this disclosure include machine learning components for optimizing parallelized search of partitions. Other examples of this disclosure include neural networks for further optimizing machine learning components.

[0108] Other aspects and examples disclosed herein relate to systems, methods, and / or one or more computer storage devices on which computer-executable instructions for object data storage are stored.

[0109] Alternatively, or in addition to the other examples described herein, examples include any combination of the following:

[0110] - Generate a profile for each object in the directory, which includes a first feature vector corresponding to the object and a globally unique identifier (GUID) corresponding to the first feature vector in the profile;

[0111] - Generate a search scope that includes at least the GUID corresponding to the profile;

[0112] - Generate a second feature vector from a live image scan;

[0113] - Use the generated search range to match the second feature vector generated from the live image scan to the first feature vector;

[0114] - A GUID that identifies the first feature vector that matches the second feature vector;

[0115] - Output information corresponding to the profile object identified by the GUID, which corresponds to the feature vector;

[0116] - Create multiple partitions within the directory;

[0117] - The profiles generated for objects in the directory will be categorized into one of the multiple partitions generated;

[0118] - The generated search scope includes multiple partitions;

[0119] - Search each of the multiple partitions in parallel for the first feature vector corresponding to the second feature vector;

[0120] - Obtain the original image data corresponding to the object;

[0121] - Generate the first feature vector corresponding to the object;

[0122] - In order to identify the GUID as corresponding to the first feature vector that matches the second feature vector, the generated second feature vector is identified as matching the first feature vector corresponding to the GUID;

[0123] - Generate a second search range, which includes the GUID corresponding to the profile;

[0124] - Generating a second feature vector from a live image scan includes performing object recognition applications;

[0125] -The object is an individual;

[0126] -Live image scanning is live face scanning;

[0127] - Receive live image scans from electronic devices;

[0128] - Generate feature vectors from live image scans;

[0129] - The generated feature vectors are tagged with a globally unique identifier (GUID);

[0130] - Identifies the search scope within a directory that includes multiple partitions within the directory, wherein the directory includes object profiles, which include information corresponding to the object and a stored GUID corresponding to the profile;

[0131] - Search in parallel the stored GUIDs corresponding to the tagged GUIDs in each of the multiple partitions;

[0132] - Identifies the profile corresponding to the GUID that is marked;

[0133] - Modify the information in the profile of the identified object;

[0134] - Delete the information from the identified object's profile; and

[0135] - Delete the profile of the identified object.

[0136] Exemplary operating environment

[0137] Figure 11This is a block diagram illustrating an example computing device 1100 for implementing the aspects disclosed herein, and is generally designated as computing device 1100. Computing device 1100 is an example of a suitable computing environment and is not intended to suggest any limitation on the scope or functionality of the examples disclosed herein. Computing device 1100 should also not be construed as having any dependencies or requirements associated with any or a combination of the components / modules shown. The examples disclosed herein can be described in the general context of computer code or machine-usable instructions, including computer-executable instructions such as program components, which are executed by a computer or other machine such as a personal digital assistant or other handheld device. Generally, a program component, including routines, programs, objects, components, data structures, etc., refers to code that performs a specific task or implements a specific abstract data type. The disclosed examples can be implemented in a variety of system configurations, including personal computers, laptops, smartphones, mobile tablets, handheld devices, consumer electronics, dedicated computing devices, etc. The disclosed examples can also be implemented in a distributed computing environment when performing tasks via a remote processing device linked through a communication network.

[0138] Computing device 1100 includes a bus 1120 that directly or indirectly couples to the following devices: computer storage memory 1102, one or more processors 1108, one or more presentation components 1110, I / O ports 1114, I / O components 1116, power supply 1118, and network components 1112. Although computing device 1100 is described as a seemingly single device, multiple computing devices 1100 can work together and share the described device resources. For example, memory 1102 can be distributed across multiple devices, and processors(s) 1108 can be housed with different devices.

[0139] Bus 1120 indicates that it can be one or more buses (e.g., address bus, data bus, or a combination thereof). Although for clarity, Figure 11 The individual blocks are shown with lines, but alternative representations can be used to depict various components. For example, in some examples, the rendering components of a display device are I / O components, and some examples of processors have their own memory. Figure 11As envisioned within the scope of this document, no distinction is made between categories such as "workstation," "server," "laptop," or "handheld device," and the term "computing device" is used herein. Memory 1102 may take the form of computer storage media referenced below and is operable to provide storage for computer-readable instructions, data structures, program modules, and other data for computing device 1100. In some examples, memory 1102 stores one or more of an operating system, a general-purpose application platform, or other program modules and program data. Therefore, memory 1102 is capable of storing and accessing data 1104 and instructions 1106, which can be executed by processor 1108 and configured to perform the various operations disclosed herein.

[0140] In some examples, memory 1102 includes volatile and / or non-volatile memory, removable or non-removable memory, a data disk in a virtual environment, or a combination thereof, as a form of computer storage medium. Memory 1102 may include any number of memories associated with or accessible by computing device 1100. Memory 1102 may be internal to computing device 1100 (e.g., Figure 11 (As shown), external to computing device 1100 or both. Examples of memory 1102 include, but are not limited to, random access memory (RAM); read-only memory (ROM); electrically erasable programmable read-only memory (EEPROM); flash memory or other memory technologies; CD-ROM, digital versatile disc (DVD) or other optical or holographic media; magnetic tape cassette, magnetic tape, disk storage or other magnetic storage devices; memory connected to an analog computing device; or any other medium used to encode desired information and accessible to computing device 1100. Additionally or alternatively, memory 1102 may be distributed across multiple computing devices 1100, for example, in a virtual environment where instruction processing is performed on multiple computing devices 1100. For the purposes of this disclosure, “computer storage medium,” “computer storage memory,” “memory,” and “storage device” are synonymous terms for computer storage memory 1102, and none of these terms include carrier waves or propagation signaling.

[0141] The (multiple) processors 1108 may include any number of processing units that read data from various entities such as memory 1102 or I / O components 816, and may include a CPU and / or a GPU. Specifically, the (multiple) processors 1108 are programmed to execute computer-executable instructions for implementing aspects of this disclosure. The instructions may be executed by a processor, by multiple processors within computing device 1100, or by a processor external to client computing device 1100. In some examples, the (multiple) processors 1108 are programmed to execute instructions such as those shown in the accompanying drawings. Furthermore, in some examples, the (multiple) processors 1108 represent an implementation of analog technology for performing the operations described herein. For example, the operations may be performed by analog client computing device 1100 and / or digital client computing device 1100. A presentation component (S) 1110 presents data indications to a user or other device. Exemplary presentation components include display devices, speakers, printing components, vibration components, etc. Those skilled in the art will understand and appreciate that computer data can be presented in various ways, such as visually in a graphical user interface (GUI), audibly through speakers, wirelessly between computing devices 1100, via a wired connection, or otherwise. I / O port 1114 allows computing device 1100 to be logically coupled to other devices including I / O components 1116, some of which may be built-in. Example I / O components 1116 include, but are not limited to, microphones, joysticks, gamepads, satellite antennas, scanners, printers, wireless devices, etc.

[0142] Computing device 1100 can operate in a networked environment via a logical connection to one or more remote computers through network component 1112. In some examples, network component 1112 includes a network interface card and / or computer-executable instructions (e.g., drivers) for operating a network interface card. Communication between computing device 1100 and other devices can occur over any wired or wireless connection using any protocol or mechanism. In some examples, network component 1112 is operable to use transport protocols over public, private, or hybrid (public and private) networks, using short-range communication technologies (e.g., Near Field Communication (NFC), Bluetooth). TM (e.g., brand communication) wirelessly transmits data between devices, or combinations thereof. Network component 1112 communicates with cloud resource 1124 across network 1126 via wireless communication link 1122 and / or wired communication link 1122a. Various examples of communication links 1122 and 1122a include wireless connections, wired connections, and / or dedicated links, and in some examples, are at least partially routed over the Internet.

[0143] Although described in conjunction with example computing devices, the examples of this disclosure can be implemented using many other general-purpose or special-purpose computing system environments, configurations, or devices. Examples of known computing systems, environments, and / or configurations suitable for use with aspects of this disclosure include, but are not limited to, smartphones, mobile tablet computers, mobile computing devices, personal computers, server computers, handheld or laptop devices, multiprocessor systems, game consoles, microprocessor-based systems, set-top boxes, programmable consumer electronics, mobile phones, mobile computing and / or wearable or accessory-type communication devices (e.g., watches, glasses, headphones), network PCs, minicomputers, mainframe computers, distributed computing environments including any of the above systems or devices, virtual reality (VR) devices, augmented reality (AR) devices, mixed reality (MR) devices, holographic devices, etc. Such systems or devices can accept input from users in any manner, including input devices such as keyboards or pointing devices, input via gestures, proximity input (such as by hovering), and / or input via voice.

[0144] Examples of this disclosure can be described in the general context of computer-executable instructions, such as program modules executed by one or more computers or other devices, including software, firmware, hardware, or combinations thereof. Computer-executable instructions can be organized into one or more computer-executable components or modules. Generally, program modules include, but are not limited to, routines, programs, objects, components, and data structures that perform a particular task or implement a particular abstract data type. Aspects of this disclosure can be implemented with any number and organization of such components or modules. For example, aspects of this disclosure are not limited to the specific computer-executable instructions or specific components or modules shown in the figures and described herein. Other examples of this disclosure may include different computer-executable instructions or components having more or fewer functions than those shown and described herein. In examples involving general-purpose computers, aspects of this disclosure transform a general-purpose computer into a special-purpose computing device when configured to execute the instructions described herein.

[0145] By way of example and not limitation, computer-readable media include computer storage media and communication media. Computer storage media include volatile and non-volatile, removable and non-removable memory implemented in any method or technology for storing information such as computer-readable instructions, data structures, program modules, etc. Computer storage media are tangible and incompatible with communication media. Computer storage media are implemented in hardware and do not include carrier waves and propagating signals. For the purposes of this disclosure, computer storage media are not signals themselves. Exemplary computer storage media include hard disks, flash drives, solid-state memory, phase-change random access memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technologies, optical disc read-only memory (CD-ROM), digital versatile disc (DVD) or other optical storage, cassette tape, magnetic tape, disk storage or other magnetic storage devices, or any other non-transfer medium that can be used to store information for access by a computing device. In contrast, communication media typically contain computer-readable instructions, data structures, program modules, etc., in modulated data signals such as carrier waves or other transmission mechanisms, and include any information delivery medium.

[0146] The execution or order of operations in the examples of this disclosure shown and described herein is not required and may be performed in different orders in various examples. For example, it is contemplated that a particular operation may be performed before, simultaneously with, or after another operation, or within the scope of aspects of this disclosure. When introducing elements of aspects of this disclosure or examples thereof, the articles “a,” “the,” and “described” are intended to indicate the presence of one or more elements. The terms “comprising,” “including,” and “having” are intended to be inclusive and mean that other elements besides those listed may be present. The term “exemplary” is intended to mean “an example thereof.” The phrase “one or more of the following: A, B, and C” means “at least one A and / or at least one B and / or at least one C.”

[0147] Having described in detail the various aspects of this disclosure, it will be apparent that modifications and variations are possible without departing from the scope of the aspects of this disclosure as defined in the appended claims. Since various changes can be made to the above structures, products, and methods without departing from the aspects of this disclosure, it is intended that all content contained in the foregoing description and shown in the accompanying drawings be interpreted as illustrative rather than restrictive.

[0148] While no aspect of this disclosure tracks personally identifiable information, examples have been described with reference to data monitored and / or collected from users. In some examples, users may be notified of data collection (e.g., via dialog boxes or preferences) and given the opportunity to give or refuse consent to the monitoring and / or collection. Consent may take the form of opting in or opting out.

[0149] Although the subject matter has been described using language specific to structural features and / or methodological actions, it should be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or actions described above. Rather, the specific features and actions described above are disclosed as exemplary forms for implementing the claims.

[0150] It should be understood that the above benefits and advantages may relate to one embodiment or multiple embodiments. The embodiments are not limited to those that solve any or all of the stated problems or have any or all of the stated benefits and advantages. It should also be understood that references to 'a' refer to one or more of these items.

[0151] In this specification, the term "comprising" means including the (multiple) features or (multiple) actions that follow, without excluding the presence of one or more additional features or actions.

[0152] In some examples, the operations shown in the figures can be implemented as software instructions encoded on a computer-readable medium, hardware programmed or designed to perform the operations, or both. For example, aspects of this disclosure can be implemented as a system-on-a-chip or other circuitry comprising multiple interconnected conductive elements.

[0153] Unless otherwise stated, the execution or order of the operations in the disclosed examples shown and described herein is not required. That is, operations may be performed in any order unless otherwise stated, and examples of this disclosure may include more or fewer operations than those disclosed herein. For example, specific operations are expected to be performed before, simultaneously with, or after another operation within the scope of various aspects of this disclosure.

Claims

1. A method for storing object data, the method comprising: Generate a first feature vector from the original image data corresponding to the object; Receive scene data, the scene data indicating a quality filter to be applied to the raw image data, wherein the scene data includes at least one of the following: physical access RGB, physical access infrared IR, and a list of scene versions captured by the camera, and the scene data is matched with the quality filter; Generate a profile for the object in the directory. The profile includes the first feature vector corresponding to the object, the scene data, and a globally unique identifier (GUID) corresponding to the first feature vector in the profile. Receive new image data corresponding to the object; The scene data is used to determine whether the new quality filter applied to the new image data matches the quality filter applied to the original image data; Based on the determination that the new quality filter matches the quality filter, the new image data is added to the profile; Generate a search range, which includes at least the GUID corresponding to the profile; A second feature vector is generated from a live image scan; Using the generated search range, the second feature vector generated from the live image scan is matched with the first feature vector; The GUID that identifies the first feature vector that matches the second feature vector; and Output information corresponding to the object of the profile identified by the GUID, which corresponds to the first feature vector.

2. The method according to claim 1, further comprising: Multiple partitions are generated within the directory; as well as The profiles generated for the objects in the directory are categorized into one of the generated partitions.

3. The method according to claim 2, wherein: The generated search range includes the multiple partitions, and The method further includes: searching each of the plurality of partitions in parallel for the first feature vector corresponding to the second feature vector.

4. The method according to claim 1, further comprising: When the new image data is added to the directory, the first feature vector is updated without invoking the training function.

5. The method according to claim 1, further comprising: In order to identify the GUID as corresponding to the first feature vector, the first feature vector is matched with the second feature vector, and the generated second feature vector is identified as matching the first feature vector corresponding to the GUID.

6. The method according to claim 1, further comprising: A second search range is generated, which includes the GUID corresponding to the profile.

7. The method of claim 1, wherein generating the second feature vector from the live image scan comprises: Execute object identification applications.

8. The method according to claim 1, wherein: The object is an individual, and The live image scan is a live facial scan.

9. A system for storing object data, the system comprising: processor; as well as A computer-readable medium storing instructions that, when executed by the processor, are operable to cause the processor to: Generate a first feature vector from the original image data corresponding to the object; Receive scene data, the scene data indicating a quality filter to be applied to the raw image data, wherein the scene data includes at least one of the following: physical access RGB, physical access infrared IR, and a list of scene versions captured by the camera, and the scene data is matched with the quality filter; A profile is generated for each object in the directory. The profile includes a first feature vector corresponding to the object, the scene data, and a globally unique identifier (GUID) corresponding to the first feature vector in the profile. Receive new image data corresponding to the object; The scene data is used to determine whether the new quality filter applied to the new image data matches the quality filter applied to the original image data; Based on the determination that the new quality filter matches the quality filter, the new image data is added to the profile; Generate a search range, which includes at least the GUID corresponding to the profile. The second feature vector is generated from the live image scan. Using the generated search range, the second feature vector generated from scanning the live image is matched with the first feature vector. The GUID that identifies the first feature vector that matches the second feature vector, and Output information corresponding to the object of the profile identified by the GUID, which corresponds to the first feature vector.

10. The system of claim 9, wherein the computer-readable medium further stores instructions that, when executed by the processor, are operable to cause the processor to: Multiple partitions are generated within the directory; and The profiles generated for the objects in the directory are categorized into one of the generated partitions.

11. The system according to claim 10, wherein: The generated search range includes the multiple partitions, and The computer-readable medium also stores instructions that, when executed by the processor, are operable to cause the processor to: search each of the plurality of partitions in parallel for the first feature vector corresponding to the second feature vector.

12. The system of claim 9, wherein the computer-readable medium further stores instructions that, when executed by the processor, are operable to cause the processor to: When the new image data is added to the directory, the first feature vector is updated without invoking the training function.

13. The system of claim 9, wherein the computer-readable medium further stores instructions that, when executed by the processor, are operable to cause the processor to: In order to identify the GUID as corresponding to the first feature vector, the first feature vector is matched with the second feature vector, and the generated second feature vector is identified as matching the first feature vector corresponding to the GUID.

14. The system of claim 9, wherein the computer-readable medium further stores instructions that, when executed by the processor, are operable to cause the processor to: A second search range is generated, which includes the GUID corresponding to the profile.

15. The system of claim 9, wherein the computer-readable medium further stores instructions operable, when executed by the processor, to cause the processor to generate the feature vector from the live image scan to perform an object algorithm application.

16. The system according to claim 9, wherein: The object is an individual, and The live image scan is a live facial scan.

Images