CN112612458A - Method and device for calling python nose print algorithm - Google Patents
Method and device for calling python nose print algorithm Download PDFInfo
- Publication number
- CN112612458A CN112612458A CN202011580760.6A CN202011580760A CN112612458A CN 112612458 A CN112612458 A CN 112612458A CN 202011580760 A CN202011580760 A CN 202011580760A CN 112612458 A CN112612458 A CN 112612458A
- Authority
- CN
- China
- Prior art keywords
- algorithm
- zmq
- service
- socket
- python
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 43
- 230000004044 response Effects 0.000 claims abstract description 38
- 238000012545 processing Methods 0.000 claims abstract description 30
- 238000004891 communication Methods 0.000 claims abstract description 26
- 230000002159 abnormal effect Effects 0.000 claims description 10
- 230000000903 blocking effect Effects 0.000 claims description 8
- 238000011161 development Methods 0.000 abstract description 19
- 238000004904 shortening Methods 0.000 abstract description 2
- 230000008878 coupling Effects 0.000 description 6
- 238000010168 coupling process Methods 0.000 description 6
- 238000005859 coupling reaction Methods 0.000 description 6
- 238000011160 research Methods 0.000 description 3
- 238000005034 decoration Methods 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 238000012549 training Methods 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 238000010586 diagram Methods 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 238000002474 experimental method Methods 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 238000004088 simulation Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/51—Source to source
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/54—Interprogram communication
- G06F9/547—Remote procedure calls [RPC]; Web services
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F2209/00—Indexing scheme relating to G06F9/00
- G06F2209/54—Indexing scheme relating to G06F9/54
- G06F2209/544—Remote
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Devices For Executing Special Programs (AREA)
Abstract
The invention relates to the field of algorithms, in particular to a method and a device for calling a python nose print algorithm. Firstly, an algorithm end and a service end determine a communication protocol format; then, an algorithm end builds ZMQ a remote service response end, initializes a model in advance, and waits for a service end to call; and finally, the service end builds ZMQ a request end, calls a response end service and obtains an algorithm processing result. The method and the device do not need to translate the nose pattern algorithm into the c language, thereby saving the development labor, improving the development efficiency and shortening the development time.
Description
Technical Field
The invention relates to the field of algorithms, in particular to a method and a device for calling a python nose print algorithm.
Background
At present, an algorithm researcher trains a large number of nose pattern pictures into a nose pattern algorithm model supported by python through tensorflow, the model needs to be initialized when the nose pattern algorithm model is called, meanwhile, a service platform is developed, the service platform is developed by using java language, and in order to integrate the nose pattern algorithm model into the service platform, a calling channel between java and python needs to be opened.
ZeroMQ (ZMQ for short) is a message queue-based multithreaded network library that abstracts the underlying details of socket type, connection handling, frames, and even routing, providing sockets across multiple transport protocols. ZMQ there are four message models: the method comprises a one-to-one association model, a request response model, a publish-subscribe model and a push-pull model, wherein the request response model is selected for remote service calling, the model is initiated by a request end, then the model waits for the response end to respond, and one request corresponds to one response. The algorithm end is used as a response end, the service end is used as a request end, and both ends are independent services and are called through ZMQ.
Currently, a mainstream called python algorithm is to translate the python algorithm into c language, and then a service platform calls the c language algorithm, the code coupling degree of the method is high, extra algorithm developers need to be invested, and some algorithm models cannot be translated into the c language.
Disclosure of Invention
The embodiment of the invention provides a method and a device for calling a python nose print algorithm, which are used for at least solving the technical problem that extra algorithm developers need to be invested when the conventional python algorithm is called.
According to an embodiment of the invention, there is provided a method of invoking a python nose print algorithm, including the steps of:
the algorithm end and the service end determine a communication protocol format;
an algorithm end builds ZMQ a remote service response end, initializes a model in advance, and waits for a service end to call;
and the service end builds ZMQ a request end, calls a response end service and obtains an algorithm processing result.
Further, the determining the communication protocol format by the algorithm side and the service side comprises:
an algorithm end service and a business end service are set up, and JSON is used as a communication protocol; JSON is a lightweight data exchange format and is a subset based on JavaScript; JSON employs a text format that is completely language independent.
Further, the format of JSON is:
when the code value is 200, the algorithm processing is successful, and when the code value is 201, the algorithm processing is abnormal, and at this time, the message is specific abnormal information.
Further, the algorithm side service sets the start ZMQ communication, and initializes the algorithm model using the REQ-REP mode of ZMQ, the REQ-REP mode of ZMQ is blocking, the REQ-REP mode of ZMQ is blocking, in which a client first sends a message to the server, and then the server returns a response to the client, and any sequence error will result in an error report.
Further, the Python algorithm service-side correlation steps are as follows:
A. creating context and socket, and connecting to an address
context＝zmq.Context(1)
socket＝context.socket(zmq.REP)
socket.setsockopt(zmq.SNDTIMEO,3000)
socket.bind(“tcp://localhost:8091”)
B. Initialization algorithm model
database_path＝“feature_list.csv”
pb_path＝“nose.pb”
dg＝noseRecognizer(pb_path＝pb_path，database_path＝database_path)
C. Opening service
t＝threading.Thread(target＝W,args＝(socket))
t.start()。
Further, the service end builds ZMQ a request end, calls a response end service, and obtains an algorithm processing result, including:
the service builds ZMQ a request end and responds to the request end ZMQ by a specific message format.
Further, the service end correlation steps are as follows:
A. creating context and socket, and connecting to an address
ZMQ.Context context＝ZMQ.context(1)；
ZMQ.Socket socket＝context.socket(ZMQ.REQ)；
socket.setReceiveTimeOut(30000)；
socket.setSendTimeOut(3000)；
socket.setReqCorrelate(true)；
socket.setReqRelaxed(true)；
socket.connect(“tcp://localhost:8091”)；
B. Sending specific message to algorithm server and receiving algorithm processing result
String msg＝“{
“type”:1，
“data”:“”
}”；
socket.send(msg)；
String reply＝socket.recvStr()。
According to another embodiment of the invention, there is provided an apparatus for invoking a python nose print algorithm, including: the method comprises an algorithm end and a service end, wherein after the algorithm end and the service end determine a communication protocol format, the algorithm end builds ZMQ a remote service response end, initializes a model in advance, waits for the service end to call, builds ZMQ a request end, calls the response end service, and obtains an algorithm processing result.
A storage medium storing a program file capable of implementing any of the above methods of invoking the python nose print algorithm.
A processor for running a program, wherein the program when running performs any of the above methods of invoking the python nose print algorithm.
According to the method and the device for calling the python nose print algorithm, firstly, an algorithm end and a service end determine a communication protocol format; then, an algorithm end builds ZMQ a remote service response end, initializes a model in advance, and waits for a service end to call; and finally, the service end builds ZMQ a request end, calls a response end service and obtains an algorithm processing result. The method and the device do not need to translate the nose pattern algorithm into the c language, thereby saving the development labor, improving the development efficiency and shortening the development time.
Drawings
The accompanying drawings, which are included to provide a further understanding of the invention and are incorporated in and constitute a part of this application, illustrate embodiment(s) of the invention and together with the description serve to explain the invention without limiting the invention. In the drawings:
FIG. 1 is a flow chart of a method of invoking the python nose print algorithm of the present invention;
FIG. 2 is a logic diagram of ZMQ one-to-one scene call in the method of calling the python nose print algorithm of the present invention.
Detailed Description
In order to make the technical solutions of the present invention better understood, the technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are only a part of the embodiments of the present invention, and not all of the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.
It should be noted that the terms "first," "second," and the like in the description and claims of the present invention and in the drawings described above are used for distinguishing between similar elements and not necessarily for describing a particular sequential or chronological order. It is to be understood that the data so used is interchangeable under appropriate circumstances such that the embodiments of the invention described herein are capable of operation in sequences other than those illustrated or described herein. Furthermore, the terms "comprises," "comprising," and "having," and any variations thereof, are intended to cover a non-exclusive inclusion, such that a process, method, system, article, or apparatus that comprises a list of steps or elements is not necessarily limited to those steps or elements expressly listed, but may include other steps or elements not expressly listed or inherent to such process, method, article, or apparatus.
Example 1
According to an embodiment of the present invention, there is provided a method of invoking the python nose print algorithm, see fig. 1-2, comprising the steps of:
s101, determining a communication protocol format by an algorithm end and a service end;
s102, an algorithm end builds ZMQ a remote service response end, initializes a model in advance and waits for a service end to call;
s103, the service end builds ZMQ request end, calls response end service and obtains algorithm processing result.
In the method for calling the python nose print algorithm in the embodiment of the invention, firstly, an algorithm end and a service end determine a communication protocol format; then, an algorithm end builds ZMQ a remote service response end, initializes a model in advance, and waits for a service end to call; and finally, the service end builds ZMQ a request end, calls a response end service and obtains an algorithm processing result. The method does not need to translate the nose pattern algorithm into the c language, saves the development labor, improves the development efficiency and shortens the development time.
Wherein, step S101 includes:
an algorithm end service and a business end service are set up, and JSON is used as a communication protocol; JSON is a lightweight data exchange format and is a subset based on JavaScript; JSON employs a text format that is completely language independent.
The JSON format is as follows:
when the code value is 200, the algorithm processing is successful, and when the code value is 201, the algorithm processing is abnormal, and at this time, the message is specific abnormal information.
The algorithm side service sets the start ZMQ communication, and uses the REQ-REP mode of ZMQ to initialize the algorithm model, the REQ-REP mode of ZMQ is blocking, the REQ-REP mode of ZMQ is blocking, in which a client sends a message to a server first, and then the server returns a response to the client, and any sequence error will cause error reporting.
The Python algorithm service end correlation steps are as follows:
A. creating context and socket, and connecting to an address
context＝zmq.Context(1)
socket＝context.socket(zmq.REP)
socket.setsockopt(zmq.SNDTIMEO,3000)
socket.bind(“tcp://localhost:8091”)
B. Initialization algorithm model
database_path＝“feature_list.csv”
pb_path＝“nose.pb”
dg＝noseRecognizer(pb_path＝pb_path，database_path＝database_path)
C. Opening service
t＝threading.Thread(target＝W,args＝(socket))
t.start()。
Wherein, step S103 includes:
the service builds ZMQ a request end and responds to the request end ZMQ by a specific message format.
The business end comprises the following relevant steps:
A. creating context and socket, and connecting to an address
ZMQ.Context context＝ZMQ.context(1)；
ZMQ.Socket socket＝context.socket(ZMQ.REQ)；
socket.setReceiveTimeOut(30000)；
socket.setSendTimeOut(3000)；
socket.setReqCorrelate(true)；
socket.setReqRelaxed(true)；
socket.connect(“tcp://localhost:8091”)；
B. Sending specific message to algorithm server and receiving algorithm processing result
String msg＝“{
“type”:1，
“data”:“”
}”；
socket.send(msg)；
String reply＝socket.recvStr()。
The method for invoking the python nose print algorithm of the present invention is described in detail below with specific embodiments:
because various algorithm libraries have very good support on python language at present, most algorithm researchers use python language to carry out algorithm research and model training, and the algorithm models need to be conveniently integrated and used after being trained, the invention provides a method for calling python nose print algorithm through ZeroMQ based on the requirements, the method can save development manpower, shorten development time and reduce code coupling degree, and the method comprises the following steps:
firstly, an algorithm end and a service end determine a communication protocol format;
then, an algorithm end builds ZMQ a remote service response end, initializes a model in advance, and waits for a service end to call;
and finally, the service end builds ZMQ a request end, calls a response end service and obtains an algorithm processing result.
The invention is described in specific detail steps below:
1) firstly, an algorithm side service and a business side service are built, JSON is used as a communication protocol (JSON, JavaScript Object notification), and the JSON is a lightweight data exchange format. It is based on a subset of JavaScript. JSON takes a text format that is completely language independent, but also uses conventions similar to the C language family (including C, C + +, C #, Java, JavaScript, Perl, Python, etc.), and the format of JSON is roughly as follows:
when the code value is 200, the algorithm processing is successful, and when the code value is 201, the algorithm processing is abnormal, and at this time, the message is specific abnormal information.
Then, the algorithm side service sets open ZMQ communication and initializes the algorithm model, using ZMQ REQ-REP mode (referring to fig. 2, REQ-REP mode is blocking, i.e. client must first send a message to server, then server can return a response to client. The Python algorithm service-side correlation steps are as follows:
A. creating context and socket, and connecting to an address
context＝zmq.Context(1)
socket＝context.socket(zmq.REP)
socket.setsockopt(zmq.SNDTIMEO,3000)
socket.bind(“tcp://localhost:8091”)
B. Initialization algorithm model
database_path＝“feature_list.csv”
pb_path＝“nose.pb”
dg＝noseRecognizer(pb_path＝pb_path，
database_path＝database_path)
C. Opening service
t＝threading.Thread(target＝W,args＝(socket))
t.start()
3) Finally, the service end builds ZMQ request end and requests ZMQ response end through specific message format, the service end correlation steps are as follows:
A. creating context and socket, and connecting to an address
ZMQ.Context context＝ZMQ.context(1)；
ZMQ.Socket socket＝context.socket(ZMQ.REQ)；
socket.setReceiveTimeOut(30000)；
socket.setSendTimeOut(3000)；
socket.setReqCorrelate(true)；
socket.setReqRelaxed(true)；
socket.connect(“tcp://localhost:8091”)；
B. Sending specific message to algorithm server and receiving algorithm processing result
String msg＝“{
“type”:1，
“data”:“”
}”；
socket.send(msg)；
String reply＝socket.recvStr()。
Example 2
According to another embodiment of the invention, there is provided an apparatus for invoking a python nose print algorithm, including: the method comprises an algorithm end and a service end, wherein after the algorithm end and the service end determine a communication protocol format, the algorithm end builds ZMQ a remote service response end, initializes a model in advance, waits for the service end to call, builds ZMQ a request end, calls the response end service, and obtains an algorithm processing result.
In the device for calling the python nose print algorithm in the embodiment of the invention, firstly, an algorithm end and a service end determine a communication protocol format; then, an algorithm end builds ZMQ a remote service response end, initializes a model in advance, and waits for a service end to call; and finally, the service end builds ZMQ a request end, calls a response end service and obtains an algorithm processing result. The device does not need to translate the nose pattern algorithm into the c language, saves the development labor, improves the development efficiency and shortens the development time.
The apparatus for invoking the python nose print algorithm of the present invention is described in detail in the following embodiments:
because various algorithm libraries have very good support on python language at present, most algorithm researchers use python language to carry out algorithm research and model training, and the algorithm models need to be conveniently integrated and used after being trained, the invention provides a device for calling python nose print algorithm through zeroMQ based on the requirements, the device can save development manpower, shorten development time and reduce code coupling degree, wherein:
firstly, an algorithm end and a service end determine a communication protocol format;
then, an algorithm end builds ZMQ a remote service response end, initializes a model in advance, and waits for a service end to call;
and finally, the service end builds ZMQ a request end, calls a response end service and obtains an algorithm processing result.
The invention is described in specific detail steps below:
1) firstly, an algorithm side service and a business side service are built, JSON is used as a communication protocol (JSON, JavaScript Object notification), and the JSON is a lightweight data exchange format. It is based on a subset of JavaScript. JSON takes a text format that is completely language independent, but also uses conventions similar to the C language family (including C, C + +, C #, Java, JavaScript, Perl, Python, etc.), and the format of JSON is roughly as follows:
when the code value is 200, the algorithm processing is successful, and when the code value is 201, the algorithm processing is abnormal, and at this time, the message is specific abnormal information.
Then, the algorithm side service sets open ZMQ communication and initializes the algorithm model, using ZMQ REQ-REP mode (referring to fig. 2, REQ-REP mode is blocking, i.e. client must first send a message to server, then server can return a response to client. The Python algorithm service-side correlation steps are as follows:
A. creating context and socket, and connecting to an address
context＝zmq.Context(1)
socket＝context.socket(zmq.REP)
socket.setsockopt(zmq.SNDTIMEO,3000)
socket.bind(“tcp://localhost:8091”)
B. Initialization algorithm model
database_path＝“feature_list.csv”
pb_path＝“nose.pb”
dg＝noseRecognizer(pb_path＝pb_path，
database_path＝database_path)
C. Opening service
t＝threading.Thread(target＝W,args＝(socket))
t.start()
3) Finally, the service end builds ZMQ request end and requests ZMQ response end through specific message format, the service end correlation steps are as follows:
A. creating context and socket, and connecting to an address
ZMQ.Context context＝ZMQ.context(1)；
ZMQ.Socket socket＝context.socket(ZMQ.REQ)；
socket.setReceiveTimeOut(30000)；
socket.setSendTimeOut(3000)；
socket.setReqCorrelate(true)；
socket.setReqRelaxed(true)；
socket.connect(“tcp://localhost:8091”)；
B. Sending specific message to algorithm server and receiving algorithm processing result
String msg＝“{
“type”:1，
“data”:“”
}”；
socket.send(msg)；
String reply＝socket.recvStr()。
The invention has the innovative technical points and the beneficial effects that:
1. the invention researches a method and a device for calling a python nose print algorithm, does not need to translate the nose print algorithm into a c language, saves the development labor, improves the development efficiency and shortens the development time.
2. The method calls the python nose print algorithm based on the form of the micro-service, and is easier to maintain in the later period.
The invention has been used by experiment, simulation and landing, the effect is obvious, and the calling speed is fast and stable. The algorithm is not limited to the nose print algorithm, but may be other algorithms requiring model initialization.
Example 3
A storage medium storing a program file capable of implementing any of the above methods of invoking the python nose print algorithm.
Example 4
A processor for running a program, wherein the program when running performs any of the above methods of invoking the python nose print algorithm.
The above-mentioned serial numbers of the embodiments of the present invention are merely for description and do not represent the merits of the embodiments.
In the above embodiments of the present invention, the descriptions of the respective embodiments have respective emphasis, and for parts that are not described in detail in a certain embodiment, reference may be made to related descriptions of other embodiments.
In the embodiments provided in the present application, it should be understood that the disclosed technology can be implemented in other ways. The above-described system embodiments are merely illustrative, and for example, a division of a unit may be a logical division, and an actual implementation may have another division, for example, multiple units or components may be combined or integrated into another system, or some features may be omitted, or not executed. In addition, the shown or discussed mutual coupling or direct coupling or communication connection may be an indirect coupling or communication connection through some interfaces, units or modules, and may be in an electrical or other form.
The units described as separate parts may or may not be physically separate, and parts displayed as units may or may not be physical units, may be located in one place, or may be distributed on a plurality of units. Some or all of the units can be selected according to actual needs to achieve the purpose of the solution of the embodiment.
In addition, functional units in the embodiments of the present invention may be integrated into one processing unit, or each unit may exist alone physically, or two or more units are integrated into one unit. The integrated unit can be realized in a form of hardware, and can also be realized in a form of a software functional unit.
The integrated unit, if implemented in the form of a software functional unit and sold or used as a stand-alone product, may be stored in a computer readable storage medium. Based on such understanding, the technical solution of the present invention may be embodied in the form of a software product, which is stored in a storage medium and includes instructions for causing a computer device (which may be a personal computer, a server, or a network device) to execute all or part of the steps of the method according to the embodiments of the present invention. And the aforementioned storage medium includes: a U-disk, a Read-Only Memory (ROM), a Random Access Memory (RAM), a removable hard disk, a magnetic or optical disk, and other various media capable of storing program codes.
The foregoing is only a preferred embodiment of the present invention, and it should be noted that, for those skilled in the art, various modifications and decorations can be made without departing from the principle of the present invention, and these modifications and decorations should also be regarded as the protection scope of the present invention.
Claims (10)
1. A method of invoking a python nose print algorithm, comprising the steps of:
the algorithm end and the service end determine a communication protocol format;
an algorithm end builds ZMQ a remote service response end, initializes a model in advance, and waits for a service end to call;
and the service end builds ZMQ a request end, calls a response end service and obtains an algorithm processing result.
2. The method of invoking python nose print algorithm as claimed in claim 1, wherein said determining the communication protocol format by the algorithm side and the service side comprises:
an algorithm end service and a business end service are set up, and JSON is used as a communication protocol; the JSON is a lightweight data exchange format and is a subset based on JavaScript; the JSON employs a text format that is completely language independent.
3. The method of invoking python nose print algorithm as recited in claim 2, wherein the JSON format is:
when the code value is 200, the algorithm processing is successful, and when the code value is 201, the algorithm processing is abnormal, and at this time, the message is specific abnormal information.
4. The method for invoking python nose print algorithm according to claim 1, wherein the algorithm side service sets start ZMQ communication and initializes algorithm model using REQ-REP mode ZMQ, wherein REQ-REP mode ZMQ is blocking, REQ-REP mode ZMQ is blocking, wherein client sends a message to server first, and then server returns a response to client, and any sequence error will result in error reporting.
5. The method of invoking Python nose print algorithm as claimed in claim 4, wherein the Python algorithm service-related steps are as follows:
A. creating context and socket, and connecting to an address
context＝zmq.Context(1)
socket＝context.socket(zmq.REP)
socket.setsockopt(zmq.SNDTIMEO,3000)
socket.bind(“tcp://localhost:8091”)
B. Initialization algorithm model
database_path＝“feature_list.csv”
pb_path＝“nose.pb”
dg＝noseRecognizer(pb_path＝pb_path，database_path＝database_path)
C. Opening service
t＝threading.Thread(target＝W,args＝(socket))
t.start()。
6. The method for invoking python nose print algorithm as claimed in claim 1, wherein the service end builds ZMQ request end, invokes response end service, and obtains algorithm processing result comprises:
the service builds ZMQ a request end and responds to the request end ZMQ by a specific message format.
7. The method of invoking python nose print algorithm as claimed in claim 6, wherein said business-related steps are as follows:
A. creating context and socket, and connecting to an address
ZMQ.Context context＝ZMQ.context(1)；
ZMQ.Socket socket＝context.socket(ZMQ.REQ)；
socket.setReceiveTimeOut(30000)；
socket.setSendTimeOut(3000)；
socket.setReqCorrelate(true)；
socket.setReqRelaxed(true)；
socket.connect(“tcp://localhost:8091”)；
B. Sending specific message to algorithm server and receiving algorithm processing result
String msg＝“{
“type”:1，
“data”:“”
}”；
socket.send(msg)；
String reply＝socket.recvStr()。
8. An apparatus for invoking a python nose print algorithm, comprising: the method comprises an algorithm end and a service end, wherein after the algorithm end and the service end determine a communication protocol format, the algorithm end builds ZMQ a remote service response end, initializes a model in advance, waits for the service end to call, builds ZMQ a request end by the service end, calls the response end service, and obtains an algorithm processing result.
9. A storage medium storing a program file capable of implementing the method of invoking the python nose print algorithm of any one of claims 1 to 7.
10. A processor, configured to run a program, wherein the program when run executes the method of invoking the python nose print algorithm of any one of claims 1 to 7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011580760.6A CN112612458A (en) | 2020-12-28 | 2020-12-28 | Method and device for calling python nose print algorithm |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011580760.6A CN112612458A (en) | 2020-12-28 | 2020-12-28 | Method and device for calling python nose print algorithm |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN112612458A true CN112612458A (en) | 2021-04-06 |
Family
ID=75248321
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202011580760.6A Pending CN112612458A (en) | 2020-12-28 | 2020-12-28 | Method and device for calling python nose print algorithm |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112612458A (en) |
Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20140215443A1 (en) * | 2013-01-28 | 2014-07-31 | Rackspace Us, Inc. | Methods and Systems of Distributed Tracing |
| US20180143810A1 (en) * | 2014-05-21 | 2018-05-24 | N.Io Innovation, Llc | System And Method For A Development Environment For Building Services For A Platform Instance |
| CN108509201A (en) * | 2018-03-20 | 2018-09-07 | 深圳神州数码云科数据技术有限公司 | A kind of code generating method and device |
| CN111190586A (en) * | 2019-12-16 | 2020-05-22 | 腾讯科技（深圳）有限公司 | Software development framework building and using method, computing device and storage medium |
| CN111897565A (en) * | 2020-06-04 | 2020-11-06 | 易通星云（北京）科技发展有限公司 | Data processing method, device and equipment based on Internet of things |
-
2020
- 2020-12-28 CN CN202011580760.6A patent/CN112612458A/en active Pending
Patent Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20140215443A1 (en) * | 2013-01-28 | 2014-07-31 | Rackspace Us, Inc. | Methods and Systems of Distributed Tracing |
| US20180143810A1 (en) * | 2014-05-21 | 2018-05-24 | N.Io Innovation, Llc | System And Method For A Development Environment For Building Services For A Platform Instance |
| CN108509201A (en) * | 2018-03-20 | 2018-09-07 | 深圳神州数码云科数据技术有限公司 | A kind of code generating method and device |
| CN111190586A (en) * | 2019-12-16 | 2020-05-22 | 腾讯科技（深圳）有限公司 | Software development framework building and using method, computing device and storage medium |
| CN111897565A (en) * | 2020-06-04 | 2020-11-06 | 易通星云（北京）科技发展有限公司 | Data processing method, device and equipment based on Internet of things |
Non-Patent Citations (4)
| Title |
|---|
| 方兵: "ONSET分布数据处理框架研究", 《中国优秀硕士学位论文全文数据库 信息科技辑》, 15 January 2019 (2019-01-15), pages 138 - 3752 * |
| 藤风: "java调用python程序", pages 1 - 8, Retrieved from the Internet <URL:《https://www.jianshu.com/p/4281ce5e137f》> * |
| 软件老王: "Java平台调用Python平台已有算法（附源码及解析）", pages 2 - 5, Retrieved from the Internet <URL:《https://www.cnblogs.com/ruanjianlaowang/p/11182544.html》> * |
| 达西布鲁斯: "Python高级用法之消息队列zmq", pages 2 - 4, Retrieved from the Internet <URL:《https://blog.csdn.net/biheyu828/article/details/88932826》> * |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN106850746B (en) | The method and device of smooth service upgrading | |
| US20190236704A1 (en) | Methods, apparatus, and systems for processing data transactions | |
| US11716264B2 (en) | In situ triggered function as a service within a service mesh | |
| CN106453536B (en) | A kind of network request processing method, server and system | |
| CN108365971A (en) | Daily record analytic method, equipment and computer-readable medium | |
| CN107547312A (en) | Applied program testing method and system | |
| US20100121947A1 (en) | System and Method for Managing the Offload Type for Offload Protocol Processing | |
| KR101468315B1 (en) | Failover system and method for high availability session reconstruction | |
| CN103248670B (en) | Connection management server and connection management method under computer network environment | |
| CN107995304A (en) | A kind of session keeping method and device based on cookie | |
| CN113259496B (en) | Bank-enterprise direct connection system and method based on financial service | |
| CN109254854A (en) | Asynchronous invoking method, computer installation and storage medium | |
| CN109104368B (en) | Connection request method, device, server and computer readable storage medium | |
| CN108667639A (en) | A kind of method for managing resource under privately owned cloud environment and management server | |
| CN109039803A (en) | A kind of method, system and the computer equipment of processing readjustment notification message | |
| CN108156223A (en) | A kind of accurate supplying system of message based on websocket and method | |
| CN108198549A (en) | Equipment control method, device, storage medium, server and user terminal | |
| CN110022323A (en) | A kind of method and system of the cross-terminal real-time, interactive based on WebSocket and Redux | |
| CN112612458A (en) | Method and device for calling python nose print algorithm | |
| CN110266610B (en) | Traffic identification method and device and electronic equipment | |
| CN108874472A (en) | A kind of the optimization display methods and system of user's head portrait | |
| CN106658224A (en) | Method for transferring audio and video data streams based on TCP mode of DSS time sharing system | |
| CN106408793B (en) | A kind of Service Component sharing method and system suitable for ATM business | |
| CN109224451A (en) | Development of games method, equipment and storage medium based on block chain subchain | |
| US7437464B1 (en) | Systems and methods for providing asynchronous messaging |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |