IMAGE DATA PROCESSING METHOD AND APPARATUS, STORAGE MEDIUM, AND PRODUCT

Description

RELATED APPLICATION

[0001] This application is proposed based on Chinese Patent Application No. 202011160161.9 and filed on October 26, 2020, and claims priority to the Chinese Patent Application.FIELD OF THE TECHNOLOGY

[0002] This application relates to the field of computer technologies, and in particular, to an image data processing method and apparatus, a computer device, a computer-readable storage medium, and a computer program product.BACKGROUND OF THE DISCLOSURE

[0003] A user (e.g., a user A), after accessing an application client (e.g., an application client C with a payment function), may collect image data associated with the user A through the application client running in a user terminal, and then directly upload the image data to a backend for identification. This means that when the backend identifies the user A as belonging to a legitimate object (e.g., a non-highly look-alike group), the application client C is allowed to execute a service (e.g., a payment service) associated with the user A.

[0004] In an object recognition manner in the related art, when the backend identifies the user A as belonging to an illegitimate object (e.g., a highly look-alike group such as a group of twins), it is difficult to identify real identity information of the user A in the highly look-alike group. As a result, an identification failure result may be directly returned to the application client, object recognition accuracy is low, and it is difficult for the user to execute the foregoing payment service in this round.

[0005] DIXIT UMESH D. ET AL: "Face-based Document Image Retrieval System", PROCEDIA COMPUTER SCIENCE, vol. 132, 31 January 2018 (2018-01-31 ), pages 659-668 discloses to retrieve documents from the database pertaining to a person based on face image, by: (i) detecting face image from query document; (ii) extracting the face image features; and (iii) retrieving all documents that contain face image similar to that of the query document. The proposed method extends the concept of grey level co-occurrence matrix to color images for feature extraction.

[0006] ABOBEAH REHAM M ET AL: "Public-Key Cryptography Techniques Evaluation", INTERNATIONAL JOURNAL OF COMPUTER NETWORKS AND APPLICATIONS, vol. 2, no. 2, 30 April 2015 (2015-04-30), pages 64-75 discloses public-key cryptography (PKC) techniques, comparing three main techniques, namely, Public key Infrastructure (PKI), Identity- Based Cryptography (IBC) and Certificate less Public Key Cryptography (CL-PKC), introducing definition, advantages and disadvantages and analysis of main problem, namely, the revocation problem, for the three techniques, highlighting a variety of available solutions to overcome the revocation problem in each technique, summarizing some common applications and schemes for each technique.

[0007] GALBALLY JAVIER ET AL: "Face Anti-spoofing Based on General Image Quality Assessment", 18TH INTERNATIONAL CONFERENCE ON PATTERN RECOGNITION (ICPR'06), IEEE COMPUTER SOCIETY, US, 24 August 2014 (2014-08-24), pages 1173-1178 discloses face anti-spoofing based on general image quality assessment suitable for real-time applications. 14 image quality features extracted from one image (i.e., the same acquired for face recognition purposes) are used to distinguish between legitimate and impostor samples.SUMMARY

[0008] The features of the method and device according to the invention are defined in the independent claims, and the preferable features are defined in the dependent claims. The following aspects are provided for illustrative purposes.

[0009] Embodiments of this application provide an image data processing method and apparatus, a computer device, a computer-readable storage medium, and a computer program product, which can improve accuracy of object recognition and ensure reliability of service execution.

[0010] An embodiment of this application provides an image data processing method, performed by a computer device, the method including: acquiring an image data stream including a target object and collected by an application client, and performing first-type identification on the target object in the image data stream based on a look-alike object database to obtain a first identification result; acquiring, in response to the first identification result indicating that the target object is a look-alike object in the look-alike object database, a look-alike identity document (ID) associated with the look-alike object, and acquiring, from a look-alike service configuration library associated with the look-alike object database, K pattern identification services configured for the look-alike ID; K being a positive integer; performing second-type identification on the target object in the image data stream respectively through the K pattern identification services to obtain K second identification results; and outputting, in response to the K second identification results indicating that the target object is the look-alike object, the look-alike ID to the application client to cause the application client to execute an application service based on the look-alike ID.

[0011] An embodiment of this application further provides an image data processing apparatus, including: a data stream acquisition module configured to acquire an image data stream including a target object and collected by an application client, and perform first-type identification on the target object in the image data stream based on a look-alike object database to obtain a first identification result; a look-alike identity acquisition module configured to acquire, in response to the first identification result indicating that the target object is a look-alike object in the look-alike object database, a look-alike ID associated with the look-alike object, and acquire, from a look-alike service configuration library associated with the look-alike object database, K pattern identification services configured for the look-alike ID; K being a positive integer; a pattern identification service module configured to perform second-type identification on the target object in the image data stream respectively through the K pattern identification services to obtain K second identification results; and a look-alike identity output module configured to output, in response to the K second identification results indicating that the target object is the look-alike object, the look-alike ID to the application client to cause the application client to execute an application service based on the look-alike ID.

[0012] An embodiment of this application further provides an image data processing method, performed by a computer device, the method including: outputting, in response to a trigger operation for an application display interface of an application client, an image collection interface of the application client; collecting an image data stream including a target object through the image collection interface, and uploading the image data stream to a service server to cause the service server to perform first-type identification on the target object in the image data stream based on a look-alike object database to obtain a first identification result; the first identification result being used for instructing the service server to acquire, from a look-alike service configuration library associated with the look-alike object database, K pattern identification services for performing second-type identification on the target object in response to the target object being a look-alike object in the look-alike object database; and receiving a look-alike ID of the target object returned by the service server based on the K pattern identification services, and executing an application service of the application client based on the look-alike ID.

[0013] An embodiment of this application further provides an image data processing apparatus, including: a collection interface output module configured to output, in response to a trigger operation for an application display interface of an application client, an image collection interface of the application client; a data stream upload module configured to collect an image data stream including a target object through the image collection interface, and upload the image data stream to a service server to cause the service server to perform first-type identification on the target object in the image data stream based on a look-alike object database to obtain a first identification result; the first identification result being used for instructing the service server to acquire, from a look-alike service configuration library associated with the look-alike object database, K pattern identification services for performing second-type identification on the target object in response to the target object being a look-alike object in the look-alike object database; and a look-alike identity receiving module configured to receive a look-alike ID of the target object returned by the service server based on the K pattern identification services, and execute an application service of the application client based on the look-alike ID.

[0014] An embodiment of this application further provides a computing device, including a processor and a memory, the processor being connected to the memory, the memory being configured to store a computer program; and the processor being configured to invoke the computer program to perform the image data processing method according to the embodiments of this application.

[0015] An embodiment of this application further provides a computer-readable storage medium, the computer-readable storage medium storing a computer program, the computer program including program instructions, the program instructions, when executed by a processor, performing the image data processing method according to the embodiments of this application.

[0016] An embodiment of this application further provides a computer program product or a computer program. The computer program product or the computer program includes computer instructions, and the computer instructions are stored in a computer-readable storage medium. A processor of a computer device reads the computer instructions from the computer-readable storage medium, and executes the computer instructions, to cause the computer device to perform the image data processing method according to the embodiments of this application.

[0017] The computer device in this embodiment of this application, when acquiring an image data stream including a target object and collected by an application client, may perform first-type identification on the target object in the image data stream based on a look-alike object database to obtain a first identification result. If the first identification result indicates that the target object is a look-alike object in the look-alike object database, the computer device may acquire a look-alike ID associated with the look-alike object, and acquire, from a look-alike service configuration library associated with the look-alike object database, K pattern identification services configured for the look-alike ID. K may be a positive integer. The computer device performs second-type identification on the target object in the image data stream respectively through the K pattern identification services to obtain K second identification results. If the K second identification results indicate that the target object is the look-alike object, the computer device may output the look-alike ID to the application client to cause the application client to execute an application service based on the look-alike ID. As can be seen, in this embodiment of this application, the computer device, when identifying an object corresponding to the target object as belonging to a look-alike user group, may perform identification again on the target object in the image data stream collected by the application client through another pattern identification service (i.e., the foregoing K pattern identification services). Therefore, user identity of the target object can be determined when target objects identified by the K pattern identification services are all consistent with the look-alike object identified by the above face recognition, and the look-alike ID (i.e., identification information for uniquely identifying user identity of a user to which the target object belongs) acquired by the foregoing look-alike object can be returned to the application client to ensure accuracy of object recognition, thereby ensuring reliability of service execution.BRIEF DESCRIPTION OF THE DRAWINGS

[0018] FIG. 1 is a schematic structural diagram of a network architecture according to an embodiment of this application. FIG. 2 is a schematic diagram of a scenario of data exchange according to an embodiment of this application. FIG. 3 is a schematic flowchart of an image data processing method according to an embodiment of this application. FIG. 4 is a schematic diagram of a scenario of acquiring an image data stream according to an embodiment of this application. FIG. 5 is a schematic diagram of a scenario of selecting a target image from a legitimate data stream according to an embodiment of this application. FIG. 6 is a schematic diagram of a scenario of constructing a look-alike object database according to an embodiment of this application. FIG. 7 is a schematic flowchart of an image data processing method according to an embodiment of this application. FIG. 8 is a schematic diagram of a scenario of resolving misidentification of a highly look-alike group through multiple pattern identification services according to an embodiment of this application. FIG. 9 is a schematic diagram of a scenario of establishing a highly look-alike service configuration library according to an embodiment of this application. FIG. 10 is a schematic flowchart of an image data processing method according to an embodiment of this application. FIG. 11 is a schematic structural diagram of an image data processing apparatus according to an embodiment of this application. FIG. 12 is a schematic diagram of a computer device according to an embodiment of this application. FIG. 13 is a schematic structural diagram of an image data processing apparatus according to an embodiment of this application. FIG. 14 is a schematic diagram of a computer device according to an embodiment of this application. FIG. 15 is a schematic structural diagram of an image data processing system according to an embodiment of this application. DESCRIPTION OF EMBODIMENTS

[0019] The features of the method and device are defined in the independent claims, and the preferable features are defined in the dependent claims. The following embodiments and examples are provided for mere illustrative purposes for highlighting specific aspects of the subject-matter.

[0020] The technical solutions in the embodiments of this application are clearly described in the following with reference to the accompanying drawings in the embodiments of this application. Apparently, the described embodiments are merely some embodiments of this application rather than all of the embodiments.

[0021] In the following descriptions, related "some embodiments" describe a subset of all possible embodiments. However, it may be understood that the "some embodiments" may be the same subset or different subsets of all the possible embodiments, and may be combined with each other without conflict.

[0022] In the following description, the involved term "first / second" is merely intended to distinguish look-alike objects but does not necessarily indicate a specific order of an object. It may be understood that "first / second" is interchangeable in terms of a specific order or sequence if permitted, so that the embodiments of this application described herein can be implemented in a sequence in addition to the sequence shown or described herein.

[0023] Artificial Intelligence (AI) is a theory, method, technology and application system that uses a digital computer or a machine controlled by the digital computer to simulate, extend, and expand human intelligence, perceive the environment, acquire knowledge, and use knowledge to obtain the best result. In other words, AI is a comprehensive technology in computer science and attempts to understand the essence of intelligence and produce a new intelligent machine that can react in a manner similar to human intelligence. AI is to study the design principles and implementation methods of various intelligent machines, to enable the machines to have the functions of perception, reasoning, and decision-making.

[0024] An AI technology is a comprehensive discipline, covering a wide range of fields including both a hardware-level technology and a software-level technology. The basic AI technology generally includes a technology such as a sensor, a dedicated AI chip, cloud computing, distributed storage, a big data processing technology, an operation / interaction system, or mechatronics. An AI software technology mainly includes fields such as a computer vision (CV) technology, a speech processing technology, a natural language processing technology, and machine learning / deep learning.

[0025] The solution provided in the embodiments of this application belong to the CV technology in the field of AI. It is to be understood that, the CV technology is a science that studies how to use a machine to "see", namely, uses a camera and a computer to replace human eyes to perform machine vision such as identification, tracking, and measurement on an object, and perform graphic processing, so that the computer processes the object into an image more suitable for human eyes to observe, or an image transmitted to an instrument for detection. As a scientific subject, the CV studies related theories and technologies, and attempts to establish an AI system that can obtain information from images or multidimensional data. The CV technologies usually include technologies such as image processing, image recognition, image semantic understanding, image retrieval, optical character recognition (OCR), video processing, video semantic understanding, video content / behavior recognition, three-dimensional object reconstruction, a 3D technology, virtual reality, augmented reality, synchronous positioning, or map construction, and further include biometric identification technologies such as common face recognition and fingerprint identification.

[0026] Referring to FIG. 1, FIG. 1 is a schematic structural diagram of a network architecture according to an embodiment of this application. As shown in FIG. 1, the network architecture may include a user terminal cluster and a service server 2000. It may be understood that the user terminal cluster herein may include one or more user terminals. A quantity of the user terminal in the user terminal cluster is not limited herein. As shown in FIG. 1, the user terminal cluster may include a plurality of user terminals, which may include, for example, a user terminal 3000a, a user terminal 3000b, a user terminal 3000c, ... , and a user terminal 3000n shown in FIG. 1. As shown in FIG. 1, the user terminal 3000a, the user terminal 3000b, the user terminal 3000c, ..., and the user terminal 3000n may each establish a network connection to the service server 2000, so that each user terminal in the user terminal cluster can perform data exchange with the service server 2000 through the network connection. For example, in an object recognition scenario, each user terminal in the user terminal cluster may be configured to acquire an image data stream including a target object. The object recognition scenario herein is a face recognition scenario. The object recognition scenario herein may be an animal identification scenario, and the like. The object recognition scenario is not be enumerated herein. This is a mere illustration which may not be part of the invention.

[0027] For ease of understanding, in this embodiment of this application, one user terminal may be selected from the plurality of user terminals shown in FIG. 1 as a target user terminal. For example, the user terminal 3000a shown in FIG. 1 may be used as the target user terminal to describe a process of data exchange between the target user terminal and the service server 2000. It may be understood that the target user terminal herein may include: smart terminals with an image collection function such as smart phones, tablet computers, laptop computers, desktop computers, and smart TVs. It may be understood that one or more application clients may run in the target user terminal. When one application client (e.g., a client A) in the application clients runs in the target user terminal, a camera (the camera herein may include a front camera and a rear camera) in the target user terminal may be invoked through the client A to collect images to take one or more pieces of collected image data as the image data stream including the target object.

[0028] It is to be understood that, in this embodiment of this application, one or more pieces of image data collected by the target user terminal may be collectively referred to as an image. A quantity of the image collected is not limited herein. The application clients may include clients with an image data collection function such as a social client, a payment client, an access control client, a multimedia client (e.g., a video client), an entertainment client (e.g., a game client), an education client, an autopilot client, and an office client.

[0029] The service server 2000 shown in FIG. 1 may be an independent physical server, or may be a server cluster or a distributed system formed by a plurality of physical servers, or may be a cloud server that provides basic cloud computing services such as a cloud service, a cloud database, cloud computing, a cloud function, cloud storage, a network service, cloud communication, a middleware service, a domain name service, a security service, a content delivery network (CDN), big data, , and an AI platform, which is not limited herein.

[0030] For ease of understanding, in this embodiment of this application, a process of authenticating the target object in the image data stream in the social client is described with an example in which the application client currently running in the target user terminal is the above social client. It may be understood that, as the object recognition scenario is the face recognition scenario, the target object herein may refer to a face of a user, and the authentication herein means that the target user terminal needs to accurately and reliably acquire an ID of the user (e.g., a user ID) before executing the corresponding application service (e.g., a payment service), so as to ensure reliability of service execution. When the object recognition scenario is the animal identification scenario, the target object herein may refer to a body of an animal (e.g., head and body parts of the animal), and the authentication herein means that the target user terminal needs to accurately and reliably acquire an ID of the animal (e.g., an animal ID) before executing the corresponding application service (e.g., a stray animal supervision service), so as to ensure reliability of service execution. This is a mere illustration which may not be part of the invention.

[0031] A process of identifying the ID of the user is described in which the object recognition scenario is the face recognition scenario. Referring to FIG. 2, FIG. 2 is a schematic diagram of a scenario of data exchange according to an embodiment of this application. The target user terminal as shown in FIG. 2 may be the user terminal 3000a shown in FIG. 1. The target user terminal as shown in FIG. 2 may display, on an application display interface (for example, the application display interface may be an image collection interface) corresponding to the application client, one or more pieces of image data associated with a target user shown in FIG. 2 and collected by a camera in the target user terminal, and determine the one or more pieces of image data collected as the image data stream including the target object. The target object herein may be a face of the target user shown in FIG. 2.

[0032] For ease of understanding, in this embodiment of this application, for example, the application client herein is the social client, and the image collection interface shown in FIG. 2 can be displayed on the target user terminal when the target user shown in FIG. 2 needs to execute a face scanning service (e.g., a face-scanning payment service) through the social client. In this case, the target user terminal may invoke a camera associated with the application client. It may be understood that the invoked camera associated with the application client may be a front camera in the object recognition scenario (i.e., the foregoing face recognition scenario) corresponding to the face scanning service. In this way, when the target user terminal acquires the one or more pieces of image data (the image data herein is facial image data) associated with the target user, such image data may be outputted and displayed on the image collection interface.

[0033] It may be understood that, as shown in FIG. 2, the target user terminal may collectively refer to each piece of image data (e.g., each piece of face image data) obtained by the above front camera shooting the face of the target user as an image. In this case, the target user terminal may obtain an image data stream 100a including the target object (i.e., the face of the target user) shown in FIG. 2 according to such facial image data including the face of the target user. As shown in FIG. 2, the image data stream 100a acquired by the service server may include a plurality of images. The plurality of images may include image data 1a, image data 1b, ..., image data 1m, and image data 1n shown in FIG. 2.

[0034] As shown in FIG. 2, when the target user terminal transmits the image data stream 100a shown in FIG. 2 to the service server shown in FIG. 2, the service server may perform first-type identification on the target object in the image data stream based on a constructed look-alike object database (i.e., a look-alike object database of objects with high similarities) to obtain a first identification result. It may be understood that the service server herein may be the service server 2000 in the foregoing embodiment corresponding to FIG. 1.

[0035] It may be understood that the objects with high similarities herein mean that a similarity between an object (i.e., the target user shown in FIG. 2, such as a user A) and another object (e.g., a user B) reaches a similarity threshold. In this case, in this embodiment of this application, the target user (such as the user A) may be classified into a look-alike user group. In this embodiment of this application, the look-alike user group herein may be collectively referred to as a first-type user. Based on the above, in this embodiment of this application, a service database corresponding to the look-alike user group (i.e., the first-type user) to which the user A belongs may be collectively referred to as a first-type database. As the above object recognition scenario is the face recognition scenario, the first-type database in which the user A is located may also be collectively referred to as a look-alike object database.

[0036] In some embodiments, in this embodiment of this application, a similarity between the target user (e.g., a user C) and another user (e.g., the user B) does not reach the similarity threshold, the user C is classified into a non-look-alike user group (i.e., it may be determined that the user C belongs to a second-type user). In addition, to facilitate distinction from the above look-alike object database, in this embodiment of this application, a service database corresponding to the non-look-alike user group (i.e., the second-type user) to which the user C belongs may be collectively referred to as a second-type database. As the above object recognition scenario is the face recognition scenario, the first-type database in which the user A is located may be collectively referred to as a normal object database.

[0037] In some embodiments, as shown in FIG. 2, the service server, when identifying, according to a first object identification result, the target user shown in FIG. 2 as belonging to the look-alike user group, may distribute the image data stream 100a shown in FIG. 2 to K pattern identification services shown in FIG. 2 to perform multiple authentications on the target object (i.e., the face of the target user) in the image data stream 100a through the K pattern identification services, so as to improve accuracy of object recognition. K is a positive integer. As shown in FIG. 2, the K pattern identification services herein may include an identification service 10a, ..., and an identification service 10k shown in FIG. 2. It may be understood that, in the pattern identification services, the identification service 10a is different from other identification services (for example, different from the identification service 10k). Based on this, K second identification results shown in FIG. 2 are obtained when the service server performs second-type identification on the target object in the image data stream 100a based on the pattern identification services. Based on the above, when the K second identification results indicate that the face of the target user (i.e., the target object) shown in FIG. 2 is a look-alike object in the foregoing look-alike object database, the service server returns a look-alike ID (e.g., a user ID1) corresponding to the look-alike object to the target user terminal shown in FIG. 2, so that the application client (e.g., the social client such as a WeChat client) running in the target user terminal executes the application service (e.g., the payment service) based on the received look-alike ID.

[0038] As can be seen, to ensure accuracy of object recognition and reliability of service execution, in this embodiment of this application, when the target user shown in FIG. 2 is identified as belonging to the look-alike user group (i.e., a highly look-alike group), the image data stream 100a shown in FIG. 2 can be distributed to another identification service so as to confirm the user identity of the target user through the another identification service. This means that, in this embodiment of this application, multiple authentications are performed on the face of the target user through multiple parallel pattern identification services, and then it is determined that the face scanning service is completed when the multiple authentications are successful.

[0039] An implementation in which the service server shown in FIG. 2 acquires the image data stream and performs multiple authentications on the target object in the image data stream through the K pattern identification services may be obtained with reference to the description in the following embodiments corresponding to FIG. 3 to FIG. 10.

[0040] In some embodiments, referring to FIG. 3, FIG. 3 is a schematic flowchart of an image data processing method according to an embodiment of this application. It may be understood that the method according to this embodiment of this application is performed by a computer device. The computer device herein includes, but is not limited to, a user terminal or a service server. For ease of understanding, in this embodiment of this application, a process of authenticating, by a service server, the target object in the acquired image data stream is described with an example in which the computer device is the service server. The service server herein may be the service server in the foregoing embodiment corresponding to FIG. 2. As shown in FIG. 3, the method may include at least the following step S101 to step S104:

[0041] Step S101: Acquire an image data stream including a target object and collected by an application client, and perform first-type identification on the target object in the image data stream based on a look-alike object database to obtain a first identification result.

[0042] In some embodiments, the user terminal (the target user terminal as shown in FIG. 2) is provided with an application client. In practical application, the user terminal runs the application client for image collection, generates a service data packet based on a collected image data stream including a target object, and transmits the service data packet to the service server. The service server acquires the service data packet uploaded by the application client, and may parse the service data packet through a streaming media service associated with the application client to obtain application signature information corresponding to the application client and the image data stream including the target object. The application signature information may be obtained after the application client signs the collected image data stream through an application private key. In some embodiments, the service server may perform signature verification on the application signature information through an application public key corresponding to the application private key. In some embodiments, the service server may determine, in response to the signature verification being successful, the application client transmitting the image data stream to be a legitimate client, so as to determine that the image data stream belongs to a legitimate data stream associated with an associated application service of the application client. In some embodiments, the service server may acquire a target image including a target object from the legitimate data stream, and perform first-type identification on the target object in the target image based on the look-alike object database to obtain the first identification result.

[0043] Herein, the target object is a user. As a mere illustration which may not be part of the invention, the target object may be different types of objects such as animals. The target object is a target user. In a process of collecting, by the target user, image data including the target object through the target user terminal, the target user terminal may determine, based on different attributes of objects (i.e., the users, or animals, which is a mere illustration and may not be part of the invention) currently presented on an image collection interface of the application client, service scenarios to which the corresponding objects belong. For example, the service scenarios herein may include the face recognition scenario, the animal identification scenario, and the like. The face recognition scenario may be a service scenario corresponding to the above face scanning service. Similarly, the animal identification scenario may be a service scenario corresponding to the above stray animal supervision service. Objects other than a user and scenarios other than face recognition are given herein as mere illustrations which may not be part of the invention.

[0044] It is to be understood that, in this embodiment of this application, when the front camera associated with the application client is enabled, the target user terminal may invoke the front camera to collect the image data stream associated with the target user. The image data stream herein may include at least one piece of image data associated with the target user. It may be understood that the target user terminal may perform object detection on the target object in the collected image data through the application client during the collection of the image data. If it is detected that the target object herein is a user, the target user terminal may determine that a service type corresponding to the application client may belong to a first service scenario. The first service scenario may be the above face recognition scenario. In some embodiments, if it is detected that the target object herein is a non-user (e.g., an animal), the target user terminal may determine that the service type corresponding to the application client may belong to a second service scenario. The second service scenario may be the above animal identification scenario.

[0045] For ease of understanding, for example, the service scenario is the first service scenario (i.e., the above face recognition scenario), and in the first service scenario (i.e., the face recognition scenario), the application client running in the target user terminal may include some clients with face identification services, such as a screen-lock client for face-based terminal unlocking, a client for face-based application login, a remote client for face-based remote verification, an access control client for face-based access control unlocking, a payment client for face-based offline payment, an attendance client for face-based attendance checking, and a pass client for face-based automatic face scanning.

[0046] In practical application, the target user terminal, when collecting the image data stream including the target object (i.e., the face of the target user) through the application client (e.g., the payment client), may sign the collected image data stream through the application private key of the application client to obtain the application signature information for the image data stream. In some embodiments, the target user terminal may encapsulate the application signature information and the image data stream to obtain a service data packet corresponding to the application client. In this case, the target user terminal may upload the service data packet carrying the application signature information to the computer device (i.e., the above service server), so that the service server can perform signature verification on the application signature information carried in the service data packet according to an application public key of the application client to ensure reliability of data sources.

[0047] For ease of understanding, in some embodiments, referring to FIG. 4, FIG. 4 is a schematic diagram of a scenario of acquiring an image data stream according to an embodiment of this application. An application display interface 300a shown in FIG. 4 is an application display interface of the above application client (e.g., the payment client; as shown in FIG. 4, the payment client may be a video client). As shown in FIG. 4, the application display interface may include a quantity selection region for an item (e.g., a movie ticket). A user 1 as shown in FIG. 4 may be the above target user. The target user (i.e., the user 1), when selecting a required quantity of items in the quantity selection region in the application display interface 300a shown in FIG. 4, may click a service control (i.e., a "Pay now" control) shown in FIG. 4. In this case, the target user terminal shown in FIG. 4 may respond to a trigger operation for the service control in the application display interface of the application client to output an image collection interface 400a shown in FIG. 4. As shown in FIG. 4, the image collection interface 400a may include collection indication information for instructing the user 1 to perform image collection. This means that the user 1 shown in FIG. 4 may perform a corresponding action based on the collection indication information to collect one or more pieces of image data including a face of the user 1 (which mainly refers to face image data of the user 1 currently collected). In this embodiment of this application, the image data including the face of the user 1 may be used as an image data stream to be uploaded to a service server shown in FIG. 4.

[0048] In some embodiments, to ensure legitimacy of the image data stream acquired by the service server, the target user terminal in this embodiment of this application may transmit the application signature information for the image data stream to the service server shown in FIG. 4 while transmitting the image data stream to the service server.

[0049] In some embodiments, the target user terminal may also pre-encapsulate the image data stream and the application signature information to transmit a service data packet obtained by encapsulation (i.e., a service data packet 30a carrying the application signature information shown in FIG. 4) to the service server shown in FIG. 4. In this way, when the service server shown in FIG. 4 acquires the service data packet 30a uploaded by the target user terminal, the service data packet 30a may be parsed through a streaming media service associated with the application client (e.g., the foregoing video client) to obtain application signature information 30b corresponding to the application client and an image data stream 30c including the target object (i.e., the face of the user 1 shown in FIG. 4). It may be understood that the application signature information 30b herein may be obtained after the application client signs the collected image data stream 30c through a locally stored application private key.

[0050] It may be understood that a core function of the streaming media service is to verify the image data stream 30c from the target user terminal. In addition, when it is determined that the user 1 belongs to the look-alike user group (i.e., the above first-type user), the streaming media service herein may also distribute the image data stream 30c to other identification services so as to provide K parallel pattern (e.g., at least two patterns) identification services in the service server. In addition, the streaming media service herein may be further used for receiving identification results obtained by the K pattern identification services, and then return the obtained identification results to the target user terminal shown in FIG. 4.

[0051] For example, the service server shown in FIG. 4 may perform, through the application public key of the application client, signature verification on the application signature information obtained by parsing, and then determine that a data source of the image data stream 30c is legitimate when the signature verification is successful. Therefore, the image data stream 30c shown in FIG. 4 can be determined to be a legitimate data stream. In some embodiments, the service server may acquire a target image including a target object from the legitimate data stream, so as to perform first-type identification on the target object in the target image based on the look-alike object database to obtain the first identification result.

[0052] For ease of understanding, in some embodiments, referring to FIG. 5, FIG. 5 is a schematic diagram of a scenario of selecting a target image from a legitimate data stream according to an embodiment of this application. It may be understood that a legitimate data stream 40a herein may be the image data stream 100a in the foregoing embodiment corresponding to FIG. 2. That is, the image in the legitimate data stream 40a may include the image in the foregoing embodiment corresponding to FIG. 2. It may be understood that, as shown in FIG. 5, in this embodiment of this application, the legitimate data stream 40a may be serialized to obtain an initial image sequence corresponding to the legitimate data stream 40a.

[0053] In some embodiments, the service server may take each image of the initial image sequence as a candidate image. As shown in FIG. 5, each candidate image in the initial image sequence may include a candidate image 2a, a candidate image 2b, ..., a candidate image 2m, and a candidate image 2n shown in FIG. 5. During the image collection, to enable in vivo detection on the target user, in general, the target user may be required to perform a corresponding action (e.g., blink, open mouth, a specific gesture, or the like) according to certain collection indication information. Therefore, some images with poor image quality may exist in the legitimate data stream (e.g., the legitimate data stream 40a in this embodiment corresponding to FIG. 5) acquired by the service server (i.e., some blurred images exist). Based on this, in this embodiment of this application, after the images in the legitimate data stream are taken as candidate images, screenshot regions including the target object (i.e., the face of the target user) can be captured from the candidate images as target object regions.

[0054] For example, as shown in FIG. 5, in this embodiment of this application, a screenshot region 3a including the face may be captured from the candidate image 2a, a screenshot region 3b including the face may be captured from the candidate image 2b, ..., a screenshot region 3m including the face may be captured from the candidate image 2m, and a screenshot region 3n including the face may be captured from the candidate image 2n. In some embodiments, as shown in FIG. 5, in this embodiment of this application, the screenshot regions including the target object and captured from the candidate images may be collectively referred to as target image regions.

[0055] In some embodiments, the service server may perform quality assessment on each captured target object region including the target object to obtain a corresponding quality assessment result. Then, the service server may filter out blurred images in the candidate images shown in FIG. 5 according to the quality assessment results (for example, the candidate image 2c may be filtered out, not shown in the figure), and then determine, in the candidate images with the blurred images filtered out, a candidate image with the highest resolution (e.g., the candidate image 2k, not shown in the figure) to be the target image including the target object. It may be understood that the target image herein may be an optimal image (e.g., the image with the highest resolution) selected from the legitimate data stream. The optimal image herein refers to the candidate image in which the screenshot region with optimal image quality is located.

[0056] In some embodiments, the service server may perform, based on a currently constructed look-alike object database, face recognition on the target object (e.g., the face of the user 1 shown in FIG. 4) in the target image through a face identification service to obtain the first identification result. It may be understood that the face identification service here may be used for identifying whether the face of the user 1 (i.e., the target user) is consistent with a face of the look-alike object (the look-alike object herein may be a look-alike user in a face recognition scenario) stored in the look-alike object database, and the target object may be determined to be the look-alike object stored in the look-alike object database if yes. This means that the object (i.e., the user 1) corresponding to the target object (i.e., the face of the user 1) belongs to the look-alike user group in which the look-alike user is located, and a identification result that the user 1 belongs to the look-alike user group may be taken as the first identification result. Then, step S102 below may be performed.

[0057] It may be understood that the target object herein may preferably be a face of a user in the face recognition scenario. In some embodiments, face recognition is a manner of biometric identification. Therefore, in embodiments of some other scenarios, the first-type identification may also be performed in other biometric identification manners (such as iris identification or fingerprint identification). The biometric identification manner adopted to perform the first-type identification is not limited herein.

[0058] Step S102: Acquire, in response to the first identification result indicating that the target object is a look-alike object in the look-alike object database, a look-alike ID associated with the look-alike object, and acquire, from a look-alike service configuration library associated with the look-alike object database, K pattern identification services configured for the look-alike ID.

[0059] K is a positive integer. It may be understood that, in the face recognition scenario, the look-alike object database may be used for storing face image data of each look-alike user. That is, the face image data of each look-alike user may be image data formed by screenshot regions in which faces with optimal quality are located and captured by the service server from image data streams historically collected. In some embodiments, the computer device may encode the captured face image data for uniquely representing each look-alike user to obtain an ID of the look-alike user. It may be understood that, in this embodiment of this application, the ID of each look-alike user (i.e., each look-alike user ID) stored in the look-alike object database may be collectively referred to as a look-alike ID.

[0060] In some embodiments, refer to FIG. 6 which is a schematic diagram of a scenario of constructing a look-alike object database according to an embodiment of this application. As shown in FIG. 6, the service server may acquire an image of each user from a user image database (e.g., a face database). For ease of understanding, in this embodiment of this application, for example, a quantity of users in the user image database is M, and the images of the users acquired by the service server may be: optimal images of the M users acquired by the service server from a large number of stored image data streams.

[0061] As shown in FIG. 6, the M users here may be a user B1, a user B2, a user B3, ..., and a user BM. As shown in FIG. 6, image data of the user B1 may be face image data 50a, image data of the user B2 may be face image data 50b, ..., and image data of the user BM may be face image data 50m. For ease of understanding, to traverse the M users to find users belonging to the look-alike user group, in this embodiment of this application, an i th< piece of face image data shown in FIG. 6 may be compared to each piece of other pieces of face image data in M pieces of face image data (e.g., the remaining (M-1) pieces of face image data except the i th< piece of face image data shown in FIG. 6) in advance to obtain face similarities (similarities for short) between the i th< piece of face image data and the other pieces of face image data. Herein, i is a positive integer less than or equal to M.

[0062] As shown in FIG. 6, in this embodiment of this application, the first (i.e., i=1) piece of face image data (e.g., the face image data 50a) shown in FIG. 6 may be taken as target face image data, other pieces of face image data except the first piece of face image data (e.g., the face image data 50b, ..., and the face image data 50m) may be taken as to-be-compared image data, and then the face image data 50a may be compared with each piece of to-be-compared image data in (M-1) pieces of to-be-compared image data to determine a similarity between a face in the face image data 50a and a face in each piece of the to-be-compared image data according to a comparison result. This means that (M-1) similarities can be obtained by calculation during the one-to-one comparison between the face image data 50a and the other pieces of face image data. The (M-1) similarities may include a similarity 1, a similarity 2, a similarity 3, ..., and a similarity (M-1) shown in FIG. 6.

[0063] For ease of understanding, in this application, the similarity 1 is assumed to be the face similarity between the face image data 50a and the face image data 50b shown in FIG. 6. Similarly, by analogy, the similarity (M-1) may be the face similarity between the face image data 50a and the face image data 50m shown in FIG. 6. In some embodiments, if the service server determines that the similarities include a similarity greater than a similarity threshold, it may be determined that the user (i.e., the user B1) corresponding to the i th< piece of face image data (e.g., the face image data 50a shown in FIG. 6) belongs to a first-type user, so that a look-alike ID (e.g., ID1) can be configured for the user (i.e., the user B1) corresponding to the i th< piece of face image data (e.g., the face image data 50a shown in FIG. 6), and the look-alike ID (e.g., the ID1) of the i th< piece of face image data can be added to a first-type database corresponding to the first-type user. The first-type database may be a database 60a shown in FIG. 6. In this case, the service server may take the database 60a, to which the look-alike ID (e.g., the ID1) of the i th< piece of face image data (e.g., the face image data 50a shown in FIG. 6) is added, as the look-alike object database. It may be understood that the look-alike object database herein may be a look-alike user group library, and users in the look-alike user group library may be users with similarities greater than the similarity threshold.

[0064] In some embodiments, in the face recognition scenario, to improve efficiency of image recognition, in this embodiment of this application, during the construction of the look-alike object database, when the look-alike ID configured for the i th< piece of face image data is added to the first-type database corresponding to the first-type user, the i th< piece of face image data may also be added to the first-type database for storage. In this way, the service server, when acquiring a new image data stream, may acquire an optimal image (i.e., the above target image) from the new image data stream to compare a face in the target image with faces in the face image data in the constructed look-alike object database, so as to improve efficiency of face comparison and help the service server to acquire the corresponding first identification result as quickly as possible.

[0065] It is to be understood that, in the face recognition scenario, if the application service to be executed by the application client running in the target user terminal has a higher requirement on identification, the service server corresponding to the application client, when identifying, through the face identification service, the similarity between the user B1 and another user (e.g., the user B2) as being greater than the similarity threshold, may classify the user B1 into the look-alike user group (i.e., it is considered that the user B1 belongs to the first-type user), and then may configure an ID (e.g., the above ID1) for the user B1 based on the face image data of the user B1, so as to add the ID of the user B1 to the database 60a shown in FIG. 6. Then, the database 60a to which the ID (e.g., the above ID1) for the user B1 is added may be collectively referred to as the look-alike object database.

[0066] Similarly, in this embodiment of this application, during the construction of the normal object database, when the object ID configured for the i th< piece of face image data is added to the second-type database corresponding to the second-type user, the i th< piece of face image data may also be added to the second-type database for storage. Details are not described herein again.

[0067] For example, it may be understood that, as shown in FIG. 6, the service server, after determining that the user B1 belongs to the first-type user (i.e., a highly look-alike user), may remove the user B1 and a user (e.g., the user B2) looking alike the user B1 from a comparison queue corresponding to the M users. Therefore, a new i th< piece of face image data (i.e., new target face image data) can be acquired from the remaining (M-2) persons in the comparison queue, new to-be-compared image data can be obtained, and then the new i th< piece of face image data (i.e., the new target face image data) can be compared to each piece of the new to-be-compared image data, until no new to-be-compared image data is left in the comparison queue corresponding to the M users. It is then determined that the service server has currently completed classification of the M users. For example, the user B1 and the user B2 in the M users may be classified into the database 60a (i.e., the first-type database) shown in FIG. 6, and the user BM in the M users is classified into the database 60b (i.e., the second-type database) shown in FIG. 6.

[0068] In some embodiments, to prevent misidentification existing in the face recognition performed by the service server by using the above face identification service, in this embodiment of this application, a corresponding quantity of pattern identification services may also be configured for the look-alike ID of each user in the look-alike object database. For example, when the similarity of the i th< piece of face image data (e.g., the face image data 50a shown in FIG. 6) is greater than the similarity threshold, the service server may configure N types of pattern identification services for the look-alike ID of the i th< piece of face image data based on the similarity of the i th< piece of face image data and registered biometric information (e.g., iris information, fingerprint information, noseprint information, or the like) entered by the user (i.e., the user B1) corresponding to the i th< piece of face image data. Herein, N may be a positive integer. One of the types corresponds to one of the pattern identification services. It may be understood that N may include K. In some embodiments, the service server may add the N pattern identification services to a configuration service database associated with the first-type user to obtain a look-alike service configuration library associated with the look-alike object database. For example, corresponding to the user B1 and the user B2 with a high similarity, a corresponding quantity of types (e.g., three types) of pattern identification services may be configured for the look-alike ID (e.g., the ID1) of the user B1 according to types (e.g., three types) of biometric information entered by the user B1. Similarly, in this embodiment of this application, a corresponding quantity of types (e.g., two types) of pattern identification services may also be configured for the look-alike ID (e.g., the ID2) of the user B2 according to types (e.g., two types) of biometric information entered by the user B2. It is to be understood that, in this embodiment of this application, types of pattern identification services configured by the service server for look-alike IDs of other users stored in the look-alike object database are not enumerated.

[0069] In some embodiments, as shown in FIG. 6, if the similarities include no similarity greater than the similarity threshold, the service server may determine that the user corresponding to the i th< piece of face image data (e.g., the face image data 50a shown in FIG. 6) belongs to a second-type user, so that another look-alike ID (i.e., an object ID, e.g., ID1') can be configured for the user corresponding to the i th< piece of face image data (e.g., the face image data 50a shown in FIG. 6). In this case, the service server may add the object ID (e.g., the ID1') of the i th< piece of face image data (e.g., the face image data 50a shown in FIG. 6) to the second-type database corresponding to the second-type user. The second-type database herein may be the database 60b shown in FIG. 6. Then, the service server may collectively refer to the second- type database, to which the object ID of the i th< piece of face image data is added, as the normal object database. It may be understood that the normal object database herein may be a non-look-alike user group library.

[0070] In some embodiments, after performing step S101 and before preforming step S102, the service server may perform the following step: If the first identification result indicates that the target object does not belong to look-alike objects in the look-alike object database, the service server may acquire an object ID of a user corresponding to the target object from the constructed normal object database (e.g., the database 60b shown in FIG. 6), and return the object ID to the application client as a normal authentication result. The normal authentication result may be used for instructing the application client to execute the application service in response to the object ID being the same as a cached ID. This means that the service server, when determining that the target object (i.e., the face of the target user) in a currently acquired image data stream does not belong to the look-alike user group, may compare the optimal image (i.e., the above target image) acquired from the image database with face image data in a normal image database. Therefore, when similarities are greater than the similarity threshold, an object ID of a user with the highest similarity to the target user can be acquired, and then the above application client can be allowed to directly execute the above application service based on the object ID.

[0071] Step S103: Perform second-type identification on the target object in the image data stream respectively through the K pattern identification services to obtain K second identification results.

[0072] In practical applications, the service server may output the K pattern identification services to a service scheduling component, and configure the image data stream for the K pattern identification services through the service scheduling component. In some embodiments, the service server may acquire a j th< pattern identification service from the K pattern identification services. j may be a positive integer less than or equal to K. In some embodiments, the service server may perform second-type identification on the target object in the image data stream through the j th< pattern identification service until the second-type identification is performed on the target object in the image data stream through each pattern identification service to obtain the K second identification results.

[0073] It is to be understood that if the user (i.e., the target user, e.g., the user 1) corresponding to the application client belongs to the look-alike user group (i.e., the first-type user), multiple pattern identification services may be acquired from a constructed look-alike service configuration library through a high resemblance identification scheduling service (i.e., the above K pattern identification services may be acquired). Therefore, the image data stream acquired in step S101 can be transmitted, through the streaming media service in the service server, to the service scheduling component configured to provide a high resemblance identification service, and the image data stream can be distributed to the K pattern identification services through the service scheduling component, enabling the K pattern identification services to extract image features from images in the image data stream in parallel to compare the corresponding type of features extracted with image features of images corresponding to other biological information historically collected and stored in a highly look-alike service configuration library, so as to obtain the K second identification results.

[0074] It may be understood that, if the K second identification results indicate that the target object (e.g., the face of the target user) in the image data stream belongs to a same user and the user is the same as the user corresponding to the look-alike object identified in the first identification result, the authentication is considered successful, and then step S104 may be performed. In some embodiments, if one or more of the K second identification results indicate that the target object (e.g., the face of the target user) in the image data stream does not belong to the same user, it may be determined that the authentication fails. Therefore, when the target object and the look-alike object do not belong to a same object, an authentication failure result for the target object can be generated, and the authentication failure result can be returned to the application client to cause the application client to output the authentication failure result on an application display interface.

[0075] Step S104: Output, in response to the K second identification results indicating that the target object is the look-alike object, the look-alike ID to the application client to cause the application client to execute an application service based on the look-alike ID.

[0076] In practical implementation, the service server may determine that the target object and the look-alike object belong to a same object if the K second identification results indicate that an ID of the target object is a look-alike ID mapped by the look-alike object. In some embodiments, the service server may take the look-alike ID as a look-alike authentication result, and return the look-alike authentication result to the application client. The look-alike authentication result is used for instructing the application client to execute the application service in response to the object ID being the same as a cached ID.

[0077] The computer device in this embodiment of this application, when acquiring an image data stream including a target object and collected by an application client, may perform first-type identification on the target object in the image data stream based on a look-alike object database to obtain a first identification result. It may be understood that the target object herein may include a face of a user (e.g., the target user). In this case, the first-type identification herein may be face recognition. In some embodiments, if the first identification result indicates that the target object is a look-alike object in the look-alike object database (e.g., the look-alike user group), the computer device may acquire a look-alike ID associated with the look-alike object, and acquire, from a look-alike service configuration library associated with the look-alike object database, K pattern identification services configured for the look-alike ID. K is a positive integer. It may be understood that the K pattern identification services here may include an iris identification service, a bone identification service, a noseprint identification service, and the like, which are not limited herein. In some embodiments, the computer device may perform second-type identification on the target object in the image data stream respectively through the K pattern identification services to obtain K second identification results. It is to be understood that the second-type identification here may be multiple parallel pattern identification services. One type of pattern identification service is one pattern identification service. In some embodiments, if the K second identification results indicate that the target object is the look-alike object, the computer device may output the look-alike ID to the application client to cause the application client to execute an application service based on the look-alike ID. As can be seen, in this embodiment of this application, the computer device, when identifying an object (i.e., the foregoing target user) corresponding to the target object as belonging to a look-alike user group, may perform identification again on the target object in the image data stream collected by the application client through another pattern identification service (i.e., the foregoing K pattern identification services). Therefore, user identity of the target object can be determined when target objects identified by the K pattern identification services are all consistent with the look-alike object identified by the above face recognition, and the look-alike ID (i.e., identification information for uniquely identifying user identity of a user to which the target object belongs) mapped by the foregoing look-alike object can be returned to the application client to ensure accuracy of object recognition. In this case, the application client may perform comparison according to the look-alike ID accurately identified and a cached ID associated with the image data stream and cached in the application client, and then may execute a corresponding application service (e.g., a payment service) when the look-alike ID is consistent with the cached ID, so as to ensure reliability of service execution.

[0078] Referring to FIG. 7, FIG. 7 is a schematic flowchart of an image data processing method according to an embodiment of this application. In some embodiments, the method according to this embodiment of this application is performed by a computer device. The computer device herein includes, but is not limited to, a user terminal or a service server. For ease of understanding, in this embodiment of this application, for example, the user terminal interacts with the service server to perform the method, the user terminal may be the target user terminal in the foregoing embodiment corresponding to FIG. 2, and the service server herein may be the service server in the foregoing embodiment corresponding to FIG. 2. As shown in FIG. 7, the method may include at least the following step S201 to step S209:

[0079] Step S201: A user terminal outputs, in response to a trigger operation for an application display interface of an application client, an image collection interface of the application client.

[0080] Herein, the application client may be a social client, a payment client, an access control client, or the like. For example, the application client is the payment client, and when a user triggers a payment operation, authentication on identity information of the user is involved, and then image collection and identification for the user are triggered.

[0081] Step S202: The user terminal collects an image data stream including a target object through the image collection interface, and uploads the image data stream to a service server.

[0082] Step S203: The service server performs first-type identification on the target object in the image data stream based on a look-alike object database to obtain a first identification result.

[0083] It may be understood that the service server may acquire, from a service data packet uploaded by the user terminal, the image data stream including the target object collected by the application client. For example, when the user terminal collects the image data stream including the target object, the user terminal may sign the image data stream through an application private key of the application client to obtain application signature information corresponding to the application client. It is to be understood that, to ensure security of data transmission between the user terminal and the service server, prior to uploading the image data stream to the service server, the user terminal in this embodiment of this application may encapsulate, in advance, the application signature information obtained by signature and the image data stream to obtain a service data packet carrying the application signature information. In this way, the service server, when acquiring the service data packet, may parse the service data packet to restore the application signature information and the image data stream. It may be understood that the service server further needs to verify reliability of a data source of the image data stream before using the image data stream for authentication. For example, the service server may perform, through an application public key of the application client, signature verification on the application signature information obtained by parsing, and then determine that the data source of the image data stream parsed by the service server is legitimate when the signature verification is successful. Therefore, the image data stream parsed by the service server can be determined to be a legitimate data stream. In some embodiments, the service server may perform first-type identification on the target object in the legitimate data stream based on a look-alike object database to obtain a first identification result.

[0084] An implementation in which the service server performs first-type identification (e.g., face recognition) on the target object in the legitimate data stream may be obtained with reference to the description of the process of face recognition by using a face identification service in the foregoing embodiment corresponding to FIG. 3. Details are not described herein again.

[0085] It may be understood that, if the first identification result indicates that the service server determines, by using the face identification service, that a similarity (e.g., 95%) between the target object (e.g., a face of a user) in the legitimate data stream and a look-alike object (e.g., a face of a highly look-alike user) stored in the look-alike object database is greater than a similarity threshold (e.g., 90%), the target object in the legitimate data stream may be temporarily determined to be the look-alike object in the look-alike object database, and then step S204 below may be performed to perform multiple authentications, so as to effectively resolve the problem of misidentification existing during the first-type identification (e.g., face recognition).

[0086] In some embodiments, if the first identification result indicates that the service server determines, by using the face identification service, that a similarity (e.g., 85%) between the target object (e.g., a face of a user) in the legitimate data stream and a look-alike object (e.g., a face of a highly look-alike user) stored in the look-alike object database is less than or equal to a similarity threshold (e.g., 90%), the target object in the legitimate data stream may be determined to be a normal object (i.e., a non-look-alike user) in the above non-look-alike object database (i.e., the normal object database), and then step S208 below may be performed.

[0087] Step S204: The service server acquires, in response to the first identification result indicating that the target object is a look-alike object in the look-alike object database, a look-alike ID associated with the look-alike object, and acquires, from a look-alike service configuration library associated with the look-alike object database, K pattern identification services configured for the look-alike ID. K is a positive integer.

[0088] It may be understood that a manner of constructing the look-alike object database herein may be obtained with reference to the description of the process of obtaining the first-type database in the foregoing embodiment corresponding to FIG. 3. Details are not described herein again.

[0089] In addition, it may be understood that, prior to the first-type identification, the service server may also pre-construct the look-alike object database for storing a look-alike ID of each user and construct the look-alike service configuration database associated with the look-alike object database. The look-alike service configuration database herein may be used for storing one or more types of pattern identification services corresponding to the look-alike ID of each user. A manner of constructing the look-alike service configuration database may be obtained with reference to the description of the process of constructing the look-alike service configuration library in the foregoing embodiment corresponding to FIG. 3. Details are not described herein again.

[0090] Step S205: The service server performs second-type identification on the target object in the image data stream respectively through the K pattern identification services to obtain K second identification results.

[0091] It may be understood that, after the service server performs step S205, if the K second identification results indicate that the target object is the look-alike object, that is, identification results obtained by the service server by using the K pattern identification services are completely consistent with the identification result obtained by the service server by using the above face identification service, the service server may perform step S206 below.

[0092] In some embodiments, if the K second identification results include at least one second identification result not indicating that the ID of the target object is the look-alike ID mapped by the look-alike object, it indirectly indicates that the identification results obtained by the service server by using the K parallel pattern identification services are not completely consistent with the identification result obtained by the service server by using the above face identification service, and then it may be quickly determined that the target object and the look-alike object do not belong to the same object. In some embodiments, when the target object and the look-alike object do not belong to the same object, the service server may generate an authentication failure result for the target object, and return the authentication failure result to the application client to cause the application client to output the authentication failure result on an application display interface.

[0093] Step S206: The service server outputs the look-alike ID to the application client in response to the K second identification results indicating that the target object is the look-alike object.

[0094] It may be understood that, after the service server performs step S205 to step S206, the user terminal may receive a look-alike ID of the target object returned by the service server based on the K pattern identification services, and in this case, the user terminal may perform step S207 below to execute an application service of the application client based on the look-alike ID.

[0095] Step S207: The user terminal executes the application service based on the look-alike ID.

[0096] It may be understood that the user terminal, when acquiring the look-alike ID returned by the service server, may compare the cached ID of the above image data stream stored in a local terminal with the look-alike ID. If the cached ID is consistent with the look-alike ID, the user terminal may allow the application client to execute a corresponding application service (for example, the application service herein may include a payment service; for example, movie tickets can be group-purchased in the application client (for example, a Tencent Video client) by face-scanning payment, so that a user corresponding to the user terminal can invite others with a same interest in watching movies to watch the movies online in a same virtual room).

[0097] In some embodiments, in step S208, in response to the first identification result indicating that the target object does not belong to look-alike objects in the look-alike object database, the service server may acquire an object ID of a user corresponding to the target object from the normal object database, take the object ID as a normal authentication result, and return the normal authentication result to the application client.

[0098] It may be understood that a manner of constructing the normal object database herein may be obtained with reference to the description of the process of obtaining the second-type database in the foregoing embodiment corresponding to FIG. 3. Details are not described herein again.

[0099] Step S209: The application client in the user terminal executes the application service in response to determining based on the normal authentication result that the object ID is the same as the cached ID.

[0100] For ease of understanding, in some embodiments, referring to FIG. 8, FIG. 8 is a schematic diagram of a scenario of resolving misidentification of a highly look-alike group through multiple pattern identification services according to an embodiment of this application. It may be understood that, when an application client shown in FIG. 8 runs in a user terminal shown in FIG. 8, the user terminal may invoke a camera (e.g., a front camera) of the user terminal through the application client (e.g., a social client) to collect one or more pieces of image data for a user (e.g., a user D).

[0101] It may be understood that, when the user D enables an image collection function, the user terminal may perform, through the application client shown in FIG. 6, object detection on an object presented on an image collection interface. If it is detected that the object in the image collection interface is the user D, a face recognition function is enabled, and then a service scenario of the application client may be determined to be the above face recognition scenario. It may be understood that, as shown in FIG. 8, the user terminal, when determining that the service scenario is the face recognition scenario, may invoke the camera to continue the collection and then upload continuously collected image data to a service server shown in FIG. 8 as a streaming media.

[0102] It may be understood that the streaming media herein means compressing a series of media data (the collected image data here) and then continuously transmitting an encapsulated data packet (i.e., the above service data packet) to the service server over a network, so that the service server can constantly acquire an image data stream including the target object to perform face recognition (i.e., the above first-type identification) through the face identification service provided by a streaming media backend (i.e., a service provided by a face identification service component) shown in FIG. 8.

[0103] It may be understood that the streaming media service (i.e., a service provided by a streaming media service component) shown in FIG. 8 can verify the image data stream from the user terminal. An implementation in which the service server verifies the image data stream may be obtained with reference to the description of the process of obtaining the legitimate data stream in the foregoing embodiment corresponding to FIG. 3. Details are not described herein again. In some embodiments, as shown in FIG. 8, the service server, when determining according to face image data stored in a highly look-alike user ID library (i.e., the above look-alike object database) shown in FIG. 8 that the target object (e.g., a face of the user D) in the image data stream belongs to a highly look-alike user (e.g., a user D') in a highly look-alike group, may acquire a look-alike ID (e.g., ID4) of the user D' from the highly look-alike user ID library (i.e., the above look-alike object database) shown in FIG. 8. As shown in FIG. 8, the highly look-alike user ID library (i.e., the above look-alike object database) herein is determined after similarity comparison (e.g., manual comparison) on a large number of face image data in a face database shown in FIG. 8. An implementation of constructing the highly look-alike user ID library may be obtained with reference to the description of the process of constructing the look-alike object database in the foregoing embodiment corresponding to FIG. 3. Details are not described herein again.

[0104] In some embodiments, the service server may read service configuration information from a highly look-alike service configuration library (i.e., the above look-alike service configuration library) shown in FIG. 8 through a high resemblance identification scheduling service (i.e., the service provided by the service scheduling component) shown in FIG. 8 to acquire K pattern identification services configured for the user D'. K patterns shown in FIG. 8 may include an iris identification service, a bone identification service, and other identification services (e.g., a noseprint identification service) shown in FIG. 8. For ease of understanding, in this embodiment of the application, for example, the K pattern identification services configured for the look-alike ID (e.g., ID4) of the user D' are an iris identification service, a bone identification service, and a noseprint identification service. As shown in FIG. 8, the service server may distribute, through the streaming media service component shown in FIG. 8, the image data stream from the user terminal to the pattern identification services associated with the service scheduling component, so that the pattern identification services each may perform second-type identification on the target object (i.e., the face of the above user D) in the acquired image data stream to obtain a identification result 1 corresponding to the iris identification service, a identification result 2 corresponding to the bone identification service, and a identification result 3 corresponding to the noseprint identification service. In this case, the service server may collectively refer to the identification results (i.e., the identification result 1, the identification result 2, and the identification result 3) identified by the pattern identification services as second identification results.

[0105] In some embodiments, as shown in FIG. 8, the service server, after obtaining the second identification results, may compare the 3 (i.e., K=3) second identification results with the first identification result through a high resemblance determination service (i.e., a service provided by a high resemblance determination service component) shown in FIG. 8 to determine whether a look-alike user identified by each second identification result and the look-alike user identified by the first identification result are a same user. If the look-alike users are the same user, it may be indirectly determined that look-alike IDs of look-alike users obtained after multiple authentications are the above ID4. Then, when the IDs are consistent, the look-alike ID (e.g., ID4) may be taken as a look-alike authentication result, and the look-alike authentication result may be returned to the application client shown in FIG. 8 through the above streaming media service component (i.e., a component for providing the streaming media service shown in FIG. 8).

[0106] In some embodiments, if the 3 second identification results include one or more second identification results and do not indicate that the ID of the target object is the look-alike ID mapped by the look-alike object, it may be determined that the target object and the look-alike object do not belong to the same object, and then an authentication failure result may be returned to the application client shown in FIG. 8 in this case.

[0107] It may be understood that, in this embodiment of this application, the above look-alike authentication result or authentication failure result may be collectively referred to as a result needing to be returned to the user terminal. In some embodiments, it may be further understood that, as shown in FIG. 8, if the service server determines based on the above first identification result that the target object in the image data stream does not belong to the highly look-alike group shown in FIG. 8, it may be indirectly determined that the target object in the image data stream belongs to a normal user in the above normal object database. This means that the above user D does not belong to the look-alike user. Therefore, an object ID of the user D can be acquired from the above normal object database, so that the object ID can be taken as a normal authentication result, and the normal authentication result can be returned to the application client shown in FIG. 8.

[0108] It may be understood that, in this embodiment of this application, before the service server acquires the K pattern identification services from the highly look-alike service configuration library through the high resemblance identification scheduling service shown in FIG. 8, the service server may also configure a corresponding quantity of pattern identification services for the ID of each user in the highly look-alike user ID library in advance. For ease of understanding, in some embodiments, referring to FIG. 9, FIG. 9 is a schematic diagram of a scenario of establishing a highly look-alike service configuration library according to an embodiment of this application. A highly look-alike user ID library shown in FIG. 9 may be the above look-alike object database. The look-alike object database as shown in FIG. 9 may include look-alike IDs of 3 look-alike users shown in FIG. 9. For example, a look-alike ID of a look-alike user 1 (e.g., the user B1 in the foregoing embodiment corresponding to FIG. 6) may be a user ID1 shown in FIG. 9. In another example, a look-alike ID of a look-alike user 2 (e.g., the user B2 in the foregoing embodiment corresponding to FIG. 6) may be a user ID2 shown in FIG. 9. By analogy, a look-alike ID of a look-alike user 3 (e.g., the user B3, not shown in the foregoing embodiment corresponding to FIG. 6) may be a user ID3 shown in FIG. 9.

[0109] It may be understood that, for the 3 users, the service server may obtain a score of each look-alike user according to high similarities between different look-alike users, so as to configure a corresponding quantity of pattern identification services for the user IDs of the look-alike users according to the score of each look-alike user and / or other biological information entered by each look-alike user during pre-registration.

[0110] For example, as shown in FIG. 9, the service server may configure 3 (i.e., N=3) pattern identification services (i.e., a pattern identification service T1, a pattern identification service T2, and a pattern identification service T3) shown in FIG. 9 for the user ID1 of the user B1 based on a score (e.g., 95) of the user B1 and three types of biological information entered by the user B1. The pattern identification service T1 may be the iris identification service in the foregoing embodiment corresponding to FIG. 8. In another example, as shown in FIG. 9, the service server may configure 2 (i.e., N=2) pattern identification services (i.e., a pattern identification service T1 and a pattern identification service T2) shown in FIG. 9 for the user ID2 of the user B2 based on a score (e.g., 95) of the user B2 and two types of biological information entered by the user B1. By analogy, as shown in FIG. 9, the service server may configure 2 (i.e., N=2) pattern identification services (i.e., a pattern identification service T1 and a pattern identification service T3) shown in FIG. 9 for the user ID3 of the user B3 based on a score (e.g., 99) of the user B3 and another two types of biological information entered by the user B1. It is to be understood that the N pattern identification services configured by the service server for each look-alike user may include, but is not limited to, the 3 types of pattern identification services shown in FIG. 9, which are not enumerated herein. In this case, the service server may construct a highly look-alike service configuration library (i.e., the above look-alike service configuration library) based on the corresponding quantity of pattern identification services configured for the 3 look-alike users.

[0111] In some embodiments, the user terminal, if detecting that the object on the image collection interface is an animal (for example, a puppy), may enable an animal identification function, and then determine the service scenario of the application client as the above animal identification scenario. This means that, when the user D currently holding the user terminal discovers a stray puppy, multiple identification may be performed on the animal with the method according to this embodiment of this application to finally confirm a real ID of the puppy, i.e., whether the puppy belongs to a stray dog in a stray dog cluster (i.e., the look-alike object database). If yes, the user terminal may generate management prompt information for the stray dog based on the ID of the stray dog returned by the service server, and then quickly and accurately help a relevant unit (e.g., an animal management department) to supervise the stray puppy.

[0112] In this embodiment of this application, the computer device, when identifying an object (i.e., the foregoing target user) corresponding to the target object as belonging to a look-alike user group, may perform identification again on the target object in the image data stream collected by the application client through another pattern identification service (i.e., the foregoing K pattern identification services). Therefore, user identity of the target object can be determined when target objects identified by the K pattern identification services are all consistent with the look-alike object identified by the above face recognition, and the look-alike ID (i.e., identification information for uniquely identifying user identity of a user to which the target object belongs) mapped by the foregoing look-alike object can be returned to the application client to ensure accuracy of object recognition. In this case, the application client may perform comparison according to the look-alike ID accurately identified and a cached ID associated with the image data stream and cached in the application client, and then may execute a corresponding application service (e.g., a payment service) when the look-alike ID is consistent with the cached ID, so as to ensure reliability of service execution. It is to be understood that, in this embodiment of this application, integration of components corresponding to multiple pattern identification services into a same computer device can effectively reduce dependency on hardware in the object recognition scenario, so as to improve user experience and then enhance viscosity between the user and the application client.

[0113] In some embodiments, referring to FIG. 10, FIG. 10 is a schematic flowchart of an image data processing method according to an embodiment of this application. The method may be performed by the above computer device. The computer device herein may be a user terminal. The user terminal may be the target user terminal in the foregoing embodiment corresponding to FIG. 2. The method may include the following step S301 to step S303:

[0114] Step S301: Output, in response to a trigger operation for an application display interface of an application client, an image collection interface of the application client.

[0115] Step S302: Collect an image data stream including a target object through the image collection interface, and upload the image data stream to a service server.

[0116] It may be understood that, when the user terminal completes step S302, the service server may acquire the image data stream, and then may perform first-type identification on the target object in the image data stream based on a look-alike object database to obtain a first identification result. It may be understood that the first identification result herein is used for instructing the service server to acquire, from a look-alike service configuration library associated with the look-alike object database, K pattern identification services for performing second-type identification on the target object when the target object is a look-alike object in the look-alike object database, to perform secondary verification on the identity of the user corresponding to the user terminal through the K pattern identification services to resolve misidentification in the highly look-alike group.

[0117] Step S303: Receive a look-alike ID of the target object returned by the service server based on the K pattern identification services, and execute an application service of the application client based on the look-alike ID.

[0118] It may be understood that implementations of step S301 to step S303 may be obtained with reference to the description of the user terminal in the foregoing embodiment corresponding to FIG. 7. Details are not described herein again.

[0119] As can be seen, in this embodiment of this application, when the user (e.g., the user 2) corresponding to the application client is identified for the first time as a highly look-alike user (e.g., the user 3) in a look-alike user group, secondary verification may be performed on the identity of the user 2 through multiple parallel pattern identification services. Therefore, when the user 2 is identified, through each pattern identification service, as belonging to a same highly look-alike user in the look-alike user group, it may be ensured that the user 2 and the highly look-alike user (e.g., the user 3) in the look-alike user group are a same user, and then a look-alike ID of the highly look-alike user (e.g., the user 3) in the look-alike user group may be outputted to the application client, so that the application client can compare a cached ID locally stored with a received ID, and if the cached ID is the same as the received ID, an application service (e.g., a payment service) corresponding to the application client may be executed.

[0120] In some embodiments, referring to FIG. 11, FIG. 11 is a schematic structural diagram of an image data processing apparatus according to an embodiment of this application. The above image data processing apparatus 1 may be a computer program (including program code) running in a computer device. For example, the image data processing apparatus 1 may be application software. The apparatus may be configured to perform corresponding steps in the method according to this embodiment of this application. The image data processing apparatus 1 may include: a data stream acquisition module 11, a look-alike identity acquisition module 12, a pattern identification service module 13, and a look-alike identity output module 14. In some embodiments, the image data processing apparatus 1 may further include: a streaming media acquisition module 15, a to-be-compared determination module 16, a similarity determination module 17, a look-alike identity configuration module 18, an object identity configuration module 19, a normal identity return module 20, an identification service configuration module 21, a configuration library determination module 22, an indication determination module 23, and a failure result generation module 24.

[0121] The data stream acquisition module 11 is configured to acquire an image data stream including a target object and collected by an application client, and perform first-type identification on the target object in the image data stream based on a look-alike object database to obtain a first identification result.

[0122] The data stream acquisition module 11 includes a data packet parsing unit 111, a signature verification unit 112, a legitimate determination unit 113, and a first identification unit 114.

[0123] The data packet parsing unit 111 is configured to acquire a service data packet uploaded by the application client, and parse the service data packet through a streaming media service associated with the application client to obtain application signature information corresponding to the application client and the image data stream including the target object. The application signature information is obtained after the application client signs the collected image data stream through an application private key.

[0124] The signature verification unit 112 is configured to perform signature verification on the application signature information through an application public key corresponding to the application private key.

[0125] The legitimate determination unit 113 is configured to determine, in response to the signature verification being successful, the application client transmitting the image data stream to be a legitimate client, and determine that the image data stream belongs to a legitimate data stream associated with an associated application service of the application client.

[0126] The first identification unit 114 is configured to acquire a target image including a target object from the legitimate data stream, and perform first-type identification on the target object in the target image based on the look-alike object database to obtain the first identification result.

[0127] The target object includes a face of a target user.

[0128] The first identification unit 114 includes: a candidate image determination subunit 1141, a quality assessment subunit 1142, a blurred image filtering subunit 1143, and a face recognition subunit 1144.

[0129] The candidate image determination subunit 1141 is configured to serialize the legitimate data stream to obtain an initial image sequence corresponding to the legitimate data stream, and take each image of the initial image sequence as a candidate image.

[0130] The quality assessment subunit 1142 is configured to determine target object regions including the target object in the candidate images, capture the corresponding target object regions including the target object from the candidate images, and perform quality assessment on each of the target object regions including the target object to obtain a quality assessment result.

[0131] The blurred image filtering subunit 1143 is configured to filter out blurred images in the candidate images according to the quality assessment results, and determine, in the candidate images with the blurred images filtered out, a candidate image with the highest resolution to be the target image including the target object.

[0132] The face recognition subunit 1144 is configured to perform face recognition on the target object in the target image based on the look-alike object database to obtain the first identification result.

[0133] Implementations of the candidate image determination subunit 1141, the quality assessment subunit 1142, the blurred image filtering subunit 1143, and the face recognition subunit 1144 may be obtained with reference to the description of the process of face recognition in the foregoing embodiment corresponding to FIG. 3. Details are not described herein again.

[0134] Implementations of the data packet parsing unit 111, the signature verification unit 112, the legitimate determination unit 113, and the first identification unit 114 may be obtained with reference to the description of the process of first-type identification in the foregoing embodiment corresponding to FIG. 3. Details are not described herein again.

[0135] The look-alike identity acquisition module 12 is configured to acquire, in response to the first identification result indicating that the target object is a look-alike object in the look-alike object database, a look-alike ID associated with the look-alike object, and acquire, from a look-alike service configuration library associated with the look-alike object database, K pattern identification services configured for the look-alike ID; K being a positive integer.

[0136] The pattern identification service module 13 is configured to perform second-type identification on the target object in the image data stream respectively through the K pattern identification services to obtain K second identification results.

[0137] The pattern identification service module 13 includes: a data stream configuration unit 131, an identification service acquisition unit 132, and a second identification unit 133.

[0138] The data stream configuration unit 131 is configured to output the K pattern identification services to a service scheduling component, and configure the image data stream for the K pattern identification services through the service scheduling component.

[0139] The identification service acquisition unit 132 is configured to acquire a j th< pattern identification service from the K pattern identification services; j being a positive integer less than or equal to K.

[0140] The second identification unit 133 is configured to perform second-type identification on the target object in the image data stream through the j th< pattern identification service until the second-type identification is performed on the target object in the image data stream through each pattern identification service to obtain the K second identification results.

[0141] Implementations of the data stream configuration unit 131, the identification service acquisition unit 132, and the second identification unit 133 may be obtained with reference to the description of the K pattern identification services in the foregoing embodiment corresponding to FIG. 3. Details are not described herein again.

[0142] The look-alike identity output module 14 is configured to output, in response to the K second identification results indicating that the target object is the look-alike object, the look-alike ID to the application client to cause the application client to execute an application service based on the look-alike ID.

[0143] The look-alike identity output module 14 includes: an object determination unit 141 and an authentication result return unit 142.

[0144] The object determination unit 141 is configured to determine that the target object and the look-alike object belong to a same object if the K second identification results indicate that an ID of the target object is a look-alike ID mapped by the look-alike object.

[0145] The authentication result return unit 142 is configured to take the look-alike ID as a look-alike authentication result, and return the look-alike authentication result to the application client. The look-alike authentication result is used for instructing the application client to execute the application service in response to the object ID being the same as a cached ID.

[0146] Implementation of the object determination unit 141 and the authentication result return unit 142 may be obtained with reference to the description of step S104 in the foregoing embodiment corresponding to FIG. 3. Details are not described herein again.

[0147] In some embodiments, the streaming media acquisition module 15 is configured to acquire streaming media information of M users; one piece of the streaming media information including face image data of one of the users; M being a positive integer.

[0148] The to-be-compared determination module 16 is configured to acquire an i th< piece of face image data from M pieces of face image data, and take the face image data in the M pieces of face image data except the i th< piece of face image data as to-be-compared image data; i being a positive integer less than or equal to M.

[0149] The similarity determination module 17 is configured to compare the i th< piece of face image data with the to-be-compared image data, and determine similarities between a face in the i th< piece of face image data and faces in the to-be-compared image data according to comparison results.

[0150] The look-alike identity configuration module 18 is configured to determine, in response to the similarities including a similarity greater than a similarity threshold, a user corresponding to the i th< piece of face image data to be a first-type user, configuring a look-alike ID for the user corresponding to the i th< piece of face image data, add the look-alike ID of the i th< piece of face image data to a first-type database corresponding to the first-type user, and take the first-type database, to which the look-alike ID of the i th< piece of face image data is added, as the look-alike object database.

[0151] In some embodiments, the object identity configuration module 19 is configured to determine, in response to the similarities including no similarity greater than the similarity threshold, the user corresponding to the i th< piece of face image data to be a second-type user, configure object ID information for the user corresponding to the i th< piece of face image data, add the object ID information of the i th< piece of face image data to a second-type database corresponding to the second-type user, and take the second-type database, to which the object ID information of the i th< piece of face image data is added, as a normal object database.

[0152] In some embodiments, the normal identity return module 20 is configured to acquire, in response to the first identification result indicating that the target object does not belong to look-alike objects in the look-alike object database, object ID information of a user corresponding to the target object, take the object ID information as a normal authentication result, and return the normal authentication result to the application client. The normal authentication result is used for instructing the application client to execute the application service in response to the object ID being the same as a cached ID.

[0153] In some embodiments, the identification service configuration module 21 is configured to configure, in response to the similarity of the i th< piece of face image data being greater than the similarity threshold, N types of pattern identification services for the look-alike ID of the i th< piece of face image data based on the similarity of the i th< piece of face image data and registered biometric information entered by the user corresponding to the i th< piece of face image data. N is a positive integer. One of the types corresponds to one of the pattern identification services.

[0154] The configuration library determination module 22 is configured to add the N pattern identification services to a configuration service database associated with the first-type user to obtain a look-alike service configuration library associated with the look-alike object database.

[0155] In some embodiments, the indication determination module 23 is configured to determine that the target object and the look-alike object do not belong to the same object in response to the K second identification results including at least one second identification result and not indicating that the ID of the target object is the look-alike ID mapped by the look-alike object.

[0156] The failure result generation module 24 is configured to generate, in response to the target object and the look-alike object not belonging to the same object, an authentication failure result for the target object, and return the authentication failure result to the application client to cause the application client to output the authentication failure result on an application display interface.

[0157] Implementations of the data stream acquisition module 11, the look-alike identity acquisition module 12, the pattern identification service module 13, and the look-alike identity output module 14 may be obtained with reference to the description of step S101 to step S104 in the foregoing embodiment corresponding to FIG. 3. Details are not described herein again. In some embodiments, implementations of the streaming media acquisition module 15, the to-be-compared determination module 16, the similarity determination module 17, the look-alike identity configuration module 18, the object identity configuration module 19, the normal identity return module 20, the identification service configuration module 21, the configuration library determination module 22, the indication determination module 23, and the failure result generation module 24 may be obtained with reference to the description of step S201 to step S209 in the foregoing embodiment corresponding to FIG. 3. Details are not described herein again. In addition, beneficial effects achieved by using the same method are not described herein again.

[0158] In some embodiments, referring to FIG. 12, FIG. 12 is a schematic structural diagram of a computer device according to an embodiment of this application. The computer device 1000 as shown in FIG. 12 may include: at least one processor 1001, for example, a CPU, at least one network interface 1004, a user interface 1003, a memory 1005, and at least one communication bus 1002. The communication bus 1002 is configured to implement connection communication between the components. The network interface 1004 may include a standard wired interface and a standard wireless interface (such as a Wi-Fi interface). The memory 1005 may be a high-speed RAM, or may be a non-volatile memory, for example, at least one magnetic disk memory. The memory 1005 may alternatively be at least one storage device located away from the processor 1001. As shown in FIG. 12, the memory 1005 used as a computer storage medium may include an operating system, a network communication module, a user interface module, and a device-control application program.

[0159] In the computer device 1000 shown in FIG. 12, the network interface 1004 is mainly configured to provide a network communication function. The user interface 1003 is mainly configured to provide an input interface for a user. The processor 1001 may be configured to invoke a device control application program stored in the memory 1005 to perform: acquiring an image data stream including a target object and collected by an application client, and performing first-type identification on the target object in the image data stream based on a look-alike object database to obtain a first identification result; acquiring, in response to the first identification result indicating that the target object is a look-alike object in the look-alike object database, a look-alike ID associated with the look-alike object, and acquiring, from a look-alike service configuration library associated with the look-alike object database, K pattern identification services configured for the look-alike ID; K being a positive integer. performing second-type identification on the target object in the image data stream respectively through the K pattern identification services to obtain K second identification results; and outputting, in response to the K second identification results indicating that the target object is the look-alike object, the look-alike ID to the application client to cause the application client to execute an application service based on the look-alike ID.

[0160] It is to be understood that, the computer device 1000 described in this embodiment of this application may implement the descriptions of the image data processing method in the embodiment corresponding to FIG. 3 or FIG. 7, or the descriptions of the image data processing apparatus 1 in the embodiment corresponding to FIG. 11. Details are not described herein again. In addition, beneficial effects achieved by using the same method are not described herein again.

[0161] In addition, an embodiment of this application further provides a computer-readable storage medium. The computer-readable storage medium stores a computer program executed by the computer device 1000 mentioned above, and the computer program includes program instructions. When executing the program instructions, the processor can implement the descriptions of the image data processing method in the embodiment corresponding to FIG. 3 or FIG. 7. Therefore, details are not described herein again. In addition, beneficial effects achieved by using the same method are not described herein again. For technical details that are not disclosed in the embodiments of the computer-readable storage medium of this application, reference may be made to the method embodiments of this application.

[0162] In some embodiments, referring to FIG. 13, FIG. 13 is a schematic structural diagram of an image data processing apparatus according to an embodiment of this application. The above image data processing apparatus 2 may be a computer program (including program code) running in a computer device. For example, the image data processing apparatus 2 may be application software. The apparatus may be configured to perform corresponding steps in the method according to this embodiment of this application. The image data processing apparatus 2 may include a collection interface output module 31, a data stream upload module 32, and a look-alike identity receiving module 33.

[0163] The collection interface output module 31 is configured to output, in response to a trigger operation for an application display interface of an application client, an image collection interface of the application client.

[0164] The data stream upload module 32 is configured to collect an image data stream including a target object through the image collection interface, and upload the image data stream to a service server to cause the service server to perform first-type identification on the target object in the image data stream based on a look-alike object database to obtain a first identification result. The first identification result is used for instructing the service server to acquire, from a look-alike service configuration library associated with the look-alike object database, K pattern identification services for performing second-type identification on the target object in response to the target object being a look-alike object in the look-alike object database.

[0165] The look-alike identity receiving module 33 is configured to receive a look-alike ID of the target object returned by the service server based on the K pattern identification services, and execute an application service of the application client based on the look-alike ID.

[0166] Implementations of the collection interface output module 31, the data stream upload module 32, and the look-alike identity receiving module 33 may be obtained with reference to the description of the process of uploading the image data stream to the user terminal and receiving the look-alike ID in the foregoing embodiment corresponding to FIG. 7 or FIG. 10. Details are not described herein again. In addition, beneficial effects achieved by using the same method are not described herein again.

[0167] In some embodiments, referring to FIG. 14, FIG. 14 is a schematic structural diagram of a computer device according to an embodiment of this application. The computer device 3000 as shown in FIG. 14 may include: at least one processor 3001, for example, a CPU, at least one network interface 3004, a user interface 3003, a memory 3005, and at least one communication bus 3002. The communication bus 3002 is configured to implement connection communication between the components. The network interface 3004 may include a standard wired interface and a standard wireless interface (such as a Wi-Fi interface). The memory 3005 may be a high-speed RAM, or may be a non-volatile memory, for example, at least one magnetic disk memory. The memory 3005 may alternatively be at least one storage device located away from the processor 3001. As shown in FIG. 14, the memory 3005 used as a computer storage medium may include an operating system, a network communication module, a user interface module, and a device-control application program.

[0168] In the computer device 3000 shown in FIG. 14, the network interface 3004 is mainly configured to provide a network communication function. The user interface 3003 is mainly configured to provide an input interface for a user. In some embodiments, the user interface 3003 may further include a display and a keyboard. The processor 3001 may be configured to invoke a device control application program stored in the memory 3005 to perform: outputting, in response to a trigger operation for an application display interface of an application client, an image collection interface of the application client; collecting an image data stream including a target object through the image collection interface, and uploading the image data stream to a service server to cause the service server to perform first-type identification on the target object in the image data stream based on a look-alike object database to obtain a first identification result; the first identification result being used for instructing the service server to acquire, from a look-alike service configuration library associated with the look-alike object database, K pattern identification services for performing second-type identification on the target object in response to the target object being a look-alike object in the look-alike object database; and receiving a look-alike ID of the target object returned by the service server based on the K pattern identification services, and executing an application service of the application client based on the look-alike ID.

[0169] It is to be understood that, the computer device 3000 described in this embodiment of this application may implement the descriptions of the image data processing method in the embodiment corresponding to FIG. 7 or FIG. 10, or the descriptions of the image data processing apparatus 2 in the embodiment corresponding to FIG. 13. Details are not described herein again. In addition, beneficial effects achieved by using the same method are not described herein again.

[0170] In addition, an embodiment of this application further provides a computer-readable storage medium. The computer-readable storage medium stores a computer program executed by the computer device 3000 mentioned above, and the computer program includes program instructions. When executing the program instructions, the processor can implement the descriptions of the image data processing method in the embodiment corresponding to FIG. 7 or FIG. 10. Therefore, details are not described herein again. In addition, beneficial effects achieved by using the same method are not described herein again. For technical details that are not disclosed in the embodiments of the computer-readable storage medium of this application, reference may be made to the method embodiments of this application.

[0171] It may be understood that, an embodiment of this application further provides a computer program product or a computer program. The computer program product or the computer program includes computer instructions, and the computer instructions are stored in a computer-readable storage medium. A processor of a computer device reads the computer instructions from the computer-readable storage medium, and executes the computer instructions, to cause the computer device to perform the descriptions of the image data processing method in the embodiment corresponding to FIG. 3, FIG. 7, or FIG. 10. Therefore, details are not described herein again. In addition, beneficial effects achieved by using the same method are not described herein again.

[0172] In some embodiments, referring to FIG. 15, FIG. 15 is a schematic structural diagram of an image data processing system according to an embodiment of this application. The image data processing system 3 may include an image data processing apparatus 100 and an image data processing apparatus 200. The image data processing apparatus 100 may be the image data processing apparatus 1 in the foregoing embodiment corresponding to FIG. 11. It may be understood that the image data processing apparatus 200 may be integrated into the service server in the foregoing embodiment corresponding to FIG. 2. Therefore, details are not described herein again. The image data processing apparatus 200 may be the image data processing apparatus 2 in the foregoing embodiment corresponding to FIG. 13. It may be understood that the image data processing apparatus 200 may be integrated into the target user terminal in the foregoing corresponding embodiment. Therefore, details are not described herein again. For technical details that are not disclosed in the embodiment of the computer storage medium of this application, refer to the descriptions of the method embodiments of this application.

[0173] A person of ordinary skill in the art may understand that all or some of the processes of the methods in the foregoing embodiments may be implemented by a computer program instructing relevant hardware. The program may be stored in a computer-readable storage medium. When the program runs, the processes of the foregoing methods in the embodiments may be performed. The foregoing storage medium may be: a magnetic disk, an optical disc, a read-only memory (ROM), or a random access memory (RAM).

[0174] The foregoing disclosure is merely exemplary embodiments of this application, and certainly is not intended to limit the protection scope of this application. Therefore, equivalent variations made according to the claims of this application shall still fall within the scope of this application.

Claims

1. A method for processing image data, performed by a computer device (1000), the method comprising: acquiring M pieces of face image data, the M pieces of face image data being respective face image data of M users, M being a positive integer; taking face image data other than target face image data in the M pieces of face image data as to-be-compared image data, the target face image data being an i-th piece of face image data of the M pieces of face image data, i being a positive integer less than or equal to M; comparing the target face image data to each piece of to-be-compared image data of the to-be-compared image data to acquire a similarity between the target face image data and the each piece of to-be-compared image data; in response to no similarity between the target face image data and the each piece of to-be-compared image data being greater than a similarity threshold, determining a user corresponding to the target face image data to be a non-look-alike user, configuring an identity document, ID, for the non-look-alike user, and adding the ID and the target face image data to a non-look-alike user database; in response to a similarity between the target face image data and another piece of face image data in the to-be-compared image data being greater than the similarity threshold, determining the user corresponding to the target face image data to be a look-alike user, configuring a look-alike ID for the look-alike user, adding the look-alike ID and the target face image data to a look-alike user database, and taking a piece of face image data other than the another piece of face image data in the to-be-compared image data as the target face image data, acquiring new to-be-compared image data to be compared to the target face image data; comparing the target face image data to each piece of the new to-be-compared image data until there is no new to-be-compared image data left, to complete classification of the M users; acquiring (S101) an image data stream (100a, 30c) comprising a face of a target user and collected by an application client; performing (S203) first-type identification on the face of the target user in the image data stream (100a, 30c) based on the look-alike user database to obtain a first identification result, by identifying whether the face of the target user is consistent with a face of the look-alike user stored in the look-alike user database; in response to the first identification result indicating that the target user is the look-alike user in the look-alike user database, acquiring (S102, S204) the look-alike ID associated with the look-alike user, and acquiring, from a look-alike service configuration library associated with the look-alike user database, K pattern identification services (10) configured for the look-alike ID, K being a second positive integer; performing (S103, S205) second-type identification on the face of the target user in the image data stream (100a, 30c) respectively through the K pattern identification services (10) to obtain K second identification results (200a); and in response to the K second identification results (200a) indicating that the target user is the look-alike user, outputting (S104, S206) the look-alike ID to the application client to cause the application client to execute an application service based on the look-alike ID.

2. The method according to claim 1, wherein acquiring the image data stream (100a, 30c) and performing first-type identification on the face of the target user in the image data stream (100a, 30c) based on the look-alike user database to obtain the first identification result comprises: acquiring a service data packet (30a) uploaded by the application client, and parsing the service data packet (30a) through a streaming media service associated with the application client to obtain application signature information (30b) corresponding to the application client and the image data stream (100a, 30c) comprising the face of the target user; the application signature information (30b) being obtained after the application client signs the collected image data stream (100a, 30c) through an application private key; performing signature verification on the application signature information (30b) through an application public key corresponding to the application private key; determining, in response to the signature verification being successful, the application client transmitting the image data stream (100a, 30c) to be a legitimate client, and determining that the image data stream (100a, 30c) belongs to a legitimate data stream (40a) associated with an associated application service of the application client; and acquiring a target image comprising the face of the target user from the legitimate data stream (40a), and performing first-type identification on the face of the target user in the target image based on the look-alike user database to obtain the first identification result.

3. The method according to claim 2, wherein acquiring the target image comprising the face of the target user from the legitimate data stream (40a), and performing first-type identification on the face of the target user in the target image based on the look-alike user database to obtain the first identification result comprises: serializing the legitimate data stream (40a) to obtain an initial image sequence corresponding to the legitimate data stream (40a), and taking each image of the initial image sequence as a candidate image (2); determining target user regions comprising the face of the target user in candidate images (2), and performing quality assessment on each of the target user regions to obtain a quality assessment result; filtering out blurred images in the candidate images (2) according to the quality assessment result, and determining, in the candidate images (2) with the blurred images filtered out, a candidate image (2) with a highest resolution to be the target image; and performing face recognition on the face of the target user in the target image based on the look-alike user database to obtain the first identification result.

4. The method according to claim 1, further comprising: in response to the first identification result indicating that the target user is not the look-alike user in the look-alike user database, acquiring (S208) an ID of the target user from the non-look-alike user database, taking the ID as a normal authentication result, and returning the normal authentication result to the application client, wherein the normal authentication result is used for instructing the application client to execute (S209) the application service in response to the ID being the same as a cached ID.

5. The method according to claim 1, further comprising: in response to the similarity between the target face image data and the another piece of face image data being greater than the similarity threshold, configuring N pattern identification services (10) for the look-alike ID based on the similarity between the target face image data and the another piece of face image data and registered biometric information entered by the look-alike user; N being a third positive integer; and adding the N pattern identification services (10) to a configuration service database associated with the look-alike user to obtain the look-alike service configuration library associated with the look-alike user database.

6. The method according to claim 1, wherein performing second-type identification on the face of the target user in the image data stream (100a, 30c) respectively through the K pattern identification services (10) to obtain the K second identification results (200a) comprises: outputting the K pattern identification services (10) to a service scheduling component, and configuring the image data stream (100a, 30c) for the K pattern identification services (10) through the service scheduling component; acquiring a j-th pattern identification service (10) from the K pattern identification services (10); j being a positive integer less than or equal to K; and performing second-type identification on the face of the target user in the image data stream (100a, 30c) through the j-th pattern identification service (10) until the second-type identification is performed on the face of the target user in the image data stream (100a, 30c) through each pattern identification service (10) to obtain the K second identification results (200a).

7. The method according to claim 1, wherein outputting the look-alike ID to the application client comprises: determining that the target user and the look-alike user is a same user in response to the K second identification results (200a) indicating that an ID of the target user is the look-alike ID of the look-alike user; and taking the look-alike ID as a look-alike authentication result, and returning the look-alike authentication result to the application client; the look-alike authentication result being used for instructing the application client to execute the application service in response to the ID being the same as a cached ID.

8. The method according to claim 7, further comprising: determining that the target user and the look-alike user is not the same user in response to at least one of the K second identification results (200a) not indicating that the ID of the target user is the look-alike ID of the look-alike user; and generating, in response to the target user and the look-alike user not being the same user, an authentication failure result for the target user, and returning the authentication failure result to the application client to cause the application client to output the authentication failure result on an application display interface (300a).

9. A computer device (1000, 3000), comprising: a processor (1001, 3001) and a memory (1005, 3005), the processor (1001, 3001) being connected to the memory (1005, 3005), the memory (1005, 3005) being configured to store a computer program, and the processor (1001, 3001) being configured to invoke the computer program, to perform the method according to any one of claims 1 to 8.

10. A computer-readable storage medium, storing a computer program, the computer program comprising program instructions, the program instructions, when executed by a processor, performing the method according to any one of claims 1 to 8.

11. A computer program product, comprising a computer program or instructions, the computer program or instructions, when executed by a processor, causing the processor to carry out the steps of the method according to any of claims 1 to 8.