JP2019212115A - Inspection device, inspection method, program, and learning device - Google Patents

Abstract

To provide an inspection device or the like capable of appropriately inspecting the descriptive contents in a contract.SOLUTION: An inspection device 1 includes: a storage unit for storing model data of each of a plurality of clauses; an acquisition unit for acquiring a contract; a discrimination unit for discriminating the part corresponding to the clause from the acquired contract; an extraction unit for extracting an important part of the contract on the basis of the difference between the model data corresponding to the clause and a sentence of each clause discriminated from the contract; and an output unit for outputting the important part.SELECTED DRAWING: Figure 1

Description

  The present invention relates to a contract inspection apparatus, inspection method, program, and learning apparatus.

  There are various ways to point out errors in sentences, such as typing errors, conversion errors, and misuse of particles. For example, Patent Document 1 discloses a document proofreading apparatus that divides a Japanese document in units of words with reference to a word dictionary and determines a portion estimated to be an error according to various rules.

JP 2006-338682 A

  However, the invention according to Patent Document 1 only estimates general grammatical errors and the like, and has not yet detected a specific content defect in accordance with the purpose of the document itself.

  In one aspect, an object is to provide an inspection device or the like that can appropriately inspect the contents of a contract.

  In one aspect, the inspection apparatus includes a storage unit that stores model data of each of a plurality of clauses, an acquisition unit that acquires a contract, and a determination unit that determines a location corresponding to the clause from the acquired contract. An extraction unit that extracts a caution part of the contract based on a difference between the model data corresponding to each clause and a sentence for each clause determined from the contract; and an output unit that outputs the caution part It is characterized by providing.

  In one aspect, the written contents of the contract can be properly inspected.

It is a schematic diagram which shows the structural example of a contract inspection system. It is a block diagram which shows the structural example of a server. It is explanatory drawing regarding a contract learning process. It is explanatory drawing regarding the production | generation process of a language model. It is explanatory drawing regarding a contract inspection process. It is explanatory drawing regarding the output process of a test result. It is a flowchart which shows an example of the process sequence of a contract document learning process. It is a flowchart which shows an example of the process sequence of a contract inspection process. FIG. 6 is an explanatory diagram showing an outline of a second embodiment. 10 is a flowchart illustrating an example of a processing procedure of contract learning processing according to the second embodiment. 10 is a flowchart illustrating an example of a processing procedure of contract inspection processing according to the second embodiment. FIG. 10 is an explanatory diagram showing an outline of a third embodiment. 10 is a flowchart illustrating an example of a processing procedure of contract inspection processing according to Embodiment 3. It is a functional block diagram which shows operation | movement of the server of the form mentioned above.

Hereinafter, the present invention will be described in detail with reference to the drawings illustrating embodiments thereof.
(Embodiment 1)
FIG. 1 is a schematic diagram illustrating a configuration example of a contract inspection system. In the present embodiment, a description will be given of a contract inspection system that detects a caution location that is presumed to be an error or the like in a description in a contract. The contract inspection system includes an information processing apparatus (inspection apparatus, learning apparatus) 1 and terminals 2, 2, 2,. Each device is connected for communication via a network N such as the Internet.

  The information processing apparatus 1 is an information processing apparatus capable of various information processing and information transmission / reception, and is, for example, a server apparatus or a personal computer. In the present embodiment, the information processing apparatus 1 is assumed to be a server apparatus, and will be read as the server 1 for convenience in the following description. The server 1 performs machine learning to learn words and phrases appearing in the contract using a predetermined contract template, and generates a language model that can identify a caution spot in the contract. The language model models a probability that a natural language sentence is generated, and includes, for example, an N-gram model and a hidden Markov model. As will be described later, in the present embodiment, the server 1 constructs a recurrent neural network (hereinafter referred to as “RNN”) as a language model from a group of contracts given for learning, and the RNN is used as the language model. Used to detect caution points from contracts to be inspected.

  In the present embodiment, the server 1 generates a different language model for each type of contract and for each clause included in the contract. The server 1 obtains a contract created by a user who uses the system from the terminal 2, and determines the type of the contract and each clause described in the contract to structure the document. Then, the server 1 analyzes the text of each clause of the structured contract using a language model that is different for each clause and type, and detects a point of caution.

  The terminal 2 is a terminal device used by each user who creates a contract, and is, for example, a personal computer or a multi-function terminal. The terminal 2 transmits a contract created by the user to the server 1 and requests a contract inspection process. The terminal 2 receives the inspection result from the server 1 and displays the caution location of the contract.

FIG. 2 is a block diagram illustrating a configuration example of the server 1. The server 1 includes a control unit 11, a main storage unit 12, a communication unit 13, and an auxiliary storage unit 14.
The control unit 11 includes an arithmetic processing unit such as one or a plurality of CPUs (Central Processing Units), MPUs (Micro-Processing Units), and GPUs (Graphics Processing Units), and stores the program P stored in the auxiliary storage unit 14. Various information processing, control processing, and the like related to the server 1 are performed by reading and executing. The main storage unit 12 is a temporary storage area such as a static random access memory (SRAM), a dynamic random access memory (DRAM), or a flash memory, and temporarily stores data necessary for the control unit 11 to execute arithmetic processing. Remember. The communication unit 13 includes a processing circuit for performing processing related to communication, and transmits and receives information to and from the outside.

  The auxiliary storage unit 14 is a large-capacity memory, a hard disk, or the like, and stores a program P and other data necessary for the control unit 11 to execute processing. In addition, the auxiliary storage unit 14 stores a category discrimination model 141 and a language model 142. The category discrimination model 141 is model data for discriminating the type of contract and the clauses in the contract. As described above, the language model 142 is language model data generated from a learning contract group, and is model data of each clause included in various contracts. As will be described later, in this embodiment, the server 1 generates a language model 142 for each type and clause of the contract and stores it in the auxiliary storage unit 14.

  The auxiliary storage unit 14 may be an external storage device connected to the server 1. Further, the server 1 may be a multi-computer composed of a plurality of computers, or may be a virtual machine constructed virtually by software.

  In the present embodiment, the server 1 is not limited to the above configuration, and may include, for example, a reading unit that reads information stored in a portable storage medium, an input unit that receives operation input, a display unit that displays an image, and the like. .

  FIG. 3 is an explanatory diagram regarding the contract learning process. 3 conceptually illustrates how the server 1 generates a plurality of language models 142, 142, 142... From a learning contract. Below, the outline | summary of the process which the server 1 performs is demonstrated.

  The server 1 acquires a model contract group which is a model of a contract document from the outside, and performs machine learning for learning the text of each model contract document. The model contract is a model of a contract to be learned by the server 1, and is an existing contract created manually, for example. First, the server 1 determines the type of the contract and each clause included in the contract from each model contract, and structures the contract. The server 1 learns each sentence of the structured contract for each contract type and each clause, and generates different language models 142.

  The type of contract is a classification that broadly divides contract contents, such as a confidentiality contract, a business consignment contract, and a joint research contract. The above is an example, and the type of contract is not particularly limited. As an example, the contract on the confidentiality agreement is conceptually illustrated on the left side of FIG. As shown by the thick line frame in FIG. 3, a general contract is divided into a plurality of clauses and the contract contents are described. The server 1 learns the text of each clause for each clause of the contract. In the present specification, the phrase “sentence” is not limited to one sentence (sentence), and includes sentences composed of a plurality of sentences. As will be described later, the server 1 learns words appearing in each clause according to the arrangement order of the words in the contract. Accordingly, the server 1 generates a language model 142 corresponding to each clause.

  First, the server 1 classifies a plurality of template contracts according to the type of contract. For example, the server 1 stores (stores) a keyword indicating the type of contract in the category determination model 141 in advance, and determines the type of contract based on whether or not the keyword is described in the template contract. To do. More specifically, for example, the server 1 stores the keyword described as the document name of the contract in the category discrimination model 141, and compares the document name described in the heading (title) of the contract with the keyword. To determine the type of template contract. In the contract shown in FIG. 3, the server 1 determines from the title “Secret Confidential Contract” that the contract is a contract related to a confidential contract.

  Furthermore, the server 1 refers to the category discrimination model 141 and specifies a sentence portion corresponding to each clause in the contract. For example, the server 1 specifies each clause based on the keyword, as in the above-described determination of the contract type. For example, the server 1 stores (stores) keywords representing each clause in the category discrimination model 141 in advance, and identifies a sentence portion in which the keyword is described as a clause portion. For example, the server 1 compares the subheading (subtitle) corresponding to the title of each clause with the keyword stored in the category discrimination model 141 to identify the clause. In the example of FIG. 3, the server 1 determines the sentence portion as a clause relating to the purpose of the contract from the subheading “purpose” of “Article 1”.

  In the above description, the server 1 determines the type and clause of the contract based on the rule base based on the keyword. However, the present embodiment is not limited to this. For example, the server 1 calculates the feature amount of each sentence of the contract that is the learning target, calculates the similarity between this and the feature amount of each type and clause sentence learned in advance, and calculates the similarity Type and clause may be specified based on

  There is a tf-idf method as a method for calculating the feature amount of each sentence in the contract. The tf-idf method is a technique for extracting a word characterizing a sentence in a sentence in a sentence (document) group, and the appearance frequency (tf; Term Frequency) and inverse document frequency (idf; Inverse Document) of each word. This is a method for calculating the importance (tf-idf value) of words based on (Frequency). By using the tf-idf method, the importance of each word appearing in the sentence is calculated, and the sentence can be expressed by a multidimensional feature (vector value) with the importance of each word as a variable. it can.

  For example, the server 1 calculates the appearance frequency and reverse document frequency of each word appearing in the text of each clause in the contract, and calculates the importance of each word from the calculated appearance frequency and reverse document frequency. The feature amount is calculated. The server 1 calculates the feature amount as described above for the text of each clause included in the various template contracts. Then, the server 1 calculates the similarity (for example, cosine similarity) between the calculated feature amount of each type and clause and the feature amount of each type and clause that has been learned in advance. The server 1 compares the calculated similarity with a predetermined threshold value to determine which type and clause of the contract each sentence corresponds to.

  When the similarity is calculated from the sentence feature and the type and clause of each sentence are determined, the determination can be performed more appropriately than when the type and clause are determined based on the rule base based on the keyword. For example, even if the clause name is “Obligation to keep confidentiality”, if the content related to intellectual property is actually described in the clause, this description will be used in the rule base based on the keyword. However, when the determination is made based on the similarity, it can be determined from the feature of the sentence as the sentence of the clause relating to the intellectual property. In this way, by calculating the similarity from the feature amount of the sentence, the type and clause of each sentence in the contract can be suitably determined.

  The server 1 repeats the above-described processing for each contract, determines the type of each of the plurality of template contracts, and determines each clause described in each template contract. That is, the server 1 performs contract structuring. The server 1 generates each language model 142 based on sentences having common types and clauses in each structured contract. For example, as shown on the right side of FIG. 3, the server 1 generates one language model 142 based on the text of each contract with the type “confidentiality agreement” and the clause “damage compensation”. To do. Similarly, for the other language models 142, the server 1 generates language models 142 according to types and clauses.

  FIG. 4 is an explanatory diagram regarding the generation process of the language model 142. In this embodiment, the server 1 constructs an RNN as the language model 142. Specifically, the server 1 constructs an LSTM (Long Short-Term Memory) which is a kind of RNN.

  The server 1 inputs the sentence structured according to the type and clause as described above to the RNN, and learns words that appear in the sentence. Here, the server 1 first performs natural language processing such as morphological analysis on the text input to the RNN, and divides it into words (elements) that are characters or character strings in a predetermined unit. The division unit is, for example, a unit such as a word or a phrase, but is not particularly limited. For example, the server 1 stores in advance a dictionary (not shown) storing a plurality of words and divides the sentence according to the words stored in the dictionary.

  Note that the server 1 may divide the sentence not in units of words, phrases, etc., but in other units. As other division units, units called subwords (partial words) can be assumed. A subword is a unit of a phrase that divides a sentence according to the frequency of appearance in the sentence, unlike normal segmentation. Generally, `` word '' used as the minimum constituent unit of a sentence is a unit that is minimized from the viewpoint of grammar, etc. meaning a character or character string in a sentence, but a subword is not a unit based on meaning, grammar, etc. It is a unit that is minimized according to the frequency used in the text. When divided in units of subwords, the server 1 can also divide technical terms specific to the contract, so that the document can be divided more suitably. In this way, the server 1 only needs to be able to divide the text of the contract for each element that is a character or character string of a predetermined unit, and the element as the division unit is not limited to a unit such as a word.

  The server 1 inputs each divided phrase to the input layer related to the RNN and performs machine learning. FIG. 4 conceptually shows the configuration of the RNN. As shown in FIG. 4, the RNN has an input layer, an intermediate layer (hidden layer), and an output layer. The input layer has a plurality of neurons that respectively accept inputs of words that appear in order from the beginning of the sentence. The output layer has a plurality of neurons corresponding to each neuron of the input layer and estimating and outputting a word that appears next to the word input to each neuron. The intermediate layer has a plurality of neurons for calculating the output value (phrase) in each neuron in the output layer with respect to the input value (phrase) in each neuron in the input layer. Each neuron in the intermediate layer performs an operation on the next input value using the operation result in the intermediate layer regarding the past input value (shown by a right-pointing arrow in FIG. 4), so that the next word to the next word Is estimated.

  The configuration of the RNN illustrated in FIG. 4 is an example, and the present embodiment is not limited to this. For example, the intermediate layer is not limited to one layer, and may be two or more layers. Further, the number of neurons in the input layer and the output layer is not limited to the same number. For example, the number of outputs is at least as good as the input.

  In this embodiment, the server 1 performs learning according to the RNN algorithm. For example, the server 1 performs learning according to other algorithms such as other deep learning, N-gram model, SVM (Support Vector Machine), Bayesian network, and decision tree. The language model 142 may be generated.

  The server 1 inputs each phrase of the learning sentence to each neuron in the input layer according to the arrangement order in the sentence, and obtains an output value from each neuron in the output layer. In the example of FIG. 4, the server 1 inputs each phrase “A”, “GA”, “Development”, “Done”... Of the learning sentence to each neuron of the corresponding input layer according to the order in the sentence. . The server 1 performs an operation in each neuron of the output layer through the intermediate layer, calculates the occurrence probability of the words appearing at an arbitrary position (order) in the sentence based on the words appearing immediately before, Estimate words that appear in. In the example of FIG. 4, the server 1 calculates and estimates the occurrence probability of the second occurrence of the phrase based on the first phrase “A”. Further, the server 1 performs estimation by calculating the occurrence probability of the third phrase based on the first and second phrases “A” and “GA”. Similarly, the server 1 estimates each word / phrase.

  The server 1 compares the estimated phrase with the actual phrase (correct value), adjusts the parameters of each neuron so that the output value from each neuron in the output layer approximates the correct value, and constructs the RNN. For example, the server 1 adjusts the weights and the like of the neurons in each network layer so that the phrase estimated as the phrase following “A” becomes the actual phrase “GA”. As a result, the server 1 generates a language model 142 that has learned the order of words in the forward direction of the learning text.

  The server 1 generates the language model 142 related to the above-described RNN for each contract type and clause. The server 1 uses the generated language models 142 to detect caution points that are presumed to be wrinkles such as errors from the contract to be examined acquired from the terminal 2.

FIG. 5 is an explanatory diagram relating to the contract inspection process. Based on FIG. 5, a process in which the server 1 extracts a caution point from a contract to be inspected will be described.
The server 1 acquires a contract created by the user from the terminal 2. First, the server 1 determines the type of the acquired contract and performs structured processing for specifying each clause in the contract. Specifically, the server 1 refers to the category discrimination model 141 in the same way as when learning a contract, and based on a rule base based on a keyword or a similarity based on a text feature such as a tf-idf method, Identify type and clause.

  As a result, as shown in FIG. 5, the server 1 discriminates the type of contract and classifies the text of the contract for each clause. Then, the server 1 compares the text of each clause in the contract with the model data (language model 142) of the corresponding type and clause, and extracts a caution location.

  Specifically, the server 1 divides the text of each clause of the contract into words of a predetermined unit, and inputs the divided words into the above-described RNN neural network according to the arrangement order. Then, the server 1 calculates the probability of occurrence of a phrase that appears next to the one or more words / phrases based on the one or more words / phrases that appear in order from the top of the sentence. For example, when considering the clause “Damage Compensation” shown in FIG. 5, the server 1 calculates the occurrence probability of the third phrase “unique” based on the first phrase “A” and the second phrase “GA”. . Similarly, the server 1 calculates the occurrence probability of the fourth word “ni” based on the first to third words “A”, “GA”, and “unique”. Similarly, the server 1 calculates the occurrence probability of each word / phrase for other clauses.

  The server 1 extracts a point of caution based on the difference between the model data (language model 142) constructed by learning the model contract and the contract to be examined according to the calculated occurrence probability. For example, the server 1 compares the calculated occurrence probability with a predetermined threshold value, and determines a word / phrase whose occurrence probability is equal to or less than the threshold value as a difference. For example, in the clause “Damage Compensation” in FIG. 5, the occurrence probability of “unique” and “ni” is low. The server 1 determines that the word / phrase whose occurrence probability is equal to or less than the threshold is a difference.

  The server 1 extracts a word or phrase corresponding to the difference as a caution location and outputs it to the terminal 2. For example, as conceptually shown on the right side of FIG. 5, the server 1 displays the word / phrase extracted as the attention part in a manner different from other words / phrases by a method such as color coding, thereby enabling the user to identify the attention part. .

  In the above description, the server 1 outputs a word / phrase whose occurrence probability is equal to or less than the threshold, that is, a difference from the model data as it is as a cautionary point. However, the present embodiment is not limited to this, and to some extent The difference between the values may be an allowable range and may not be a cautionary point. For example, the server 1 may assume that a place where a plurality of words having an occurrence probability equal to or less than a threshold value is a caution place, and a place where only one word having an occurrence probability less than or equal to the threshold value does not have to be a caution place. As described above, the server 1 only needs to be able to extract the caution portion by comparing with the model data of the contract, and does not need to output all the portions corresponding to the differences as the caution portion.

  FIG. 6 is an explanatory diagram regarding the output processing of the inspection result. In the above description, it has been described that the server 1 outputs (displays) a caution location by a method such as color coding. Further, in the present embodiment, the server 1 may not only output the caution portion, but also output a correction candidate of the caution portion and output an example sentence (template) of a clause that is not described.

  For example, as shown in the upper right part of FIG. 6, the server 1 outputs a sentence correction candidate including a caution location to the terminal 2. As described above, by using the language model 142, the server 1 can calculate the probability of occurrence of a phrase that appears in the text of each clause from the previous phrases. The server 1 outputs, to the terminal 2, the word / phrase having the highest occurrence probability at the position (order) in which the word / phrase is described, as the correction candidate. In the example illustrated in FIG. 6, the server 1 outputs the phrase “reason” having the highest occurrence probability as a correction candidate instead of the phrase “reason” extracted as the caution location. Note that the server 1 may output not only the phrase conversion but also a sentence in which the phrase is deleted or added as a correction candidate.

  Further, the server 1 may refer to the category discrimination model 141 to identify a clause that is not described in the contract to be examined and output an example sentence (template) of the identified clause. For example, the server 1 stores the example sentences of the clauses of various contracts, and outputs the example sentences of the clauses when the necessary clauses are not determined from the contract to be inspected. Thereby, the user can prevent omission of description of necessary clauses.

  As described above, the server 1 structures the contract to be inspected for each clause (and for each type), and extracts a cautionary point for each clause compared with the model data (language model 142). By performing the above-described processing for each clause, it is possible to accurately extract a caution spot and notify the user.

FIG. 7 is a flowchart illustrating an example of a procedure of the contract document learning process. Based on FIG. 7, the processing content of the learning process which the server 1 performs is demonstrated.
The control unit 11 of the server 1 acquires a template contract that is a template of the contract (step S11). The control unit 11 refers to the category determination model 141 and executes a structured process for determining the type of the acquired template contract and each clause included in the contract (step S12). For example, the control unit 11 stores words / phrases as keywords of various types and clauses in the category discrimination model 141 in advance, and discriminates the keywords from the template contract, thereby including the type of contract and the contract. Distinguish from the text of each clause. Further, for example, the control unit 11 prepares a category discrimination model 141 in which feature amounts of various types and clauses are stored in advance by the tf-idf method and the like, and each sentence stored in the category discrimination model 141 is prepared. The similarity is calculated from the feature quantity and the feature quantity of each sentence included in the template contract, and the type and clause are determined according to the calculated similarity degree.

  The control unit 11 divides the text of each clause into a plurality of words (elements) that are characters or character strings of a predetermined unit (step S13). For example, the control unit 11 may divide a sentence by a semantic unit such as a word or a phrase, or may divide a sentence by a unit corresponding to the appearance frequency of a subword or the like.

  The control unit 11 performs a machine learning process of learning a phrase that appears next to each divided phrase in the order in which the sentences are arranged, and generates model data (language model 142) for each clause and type (step S14). For example, the control unit 11 performs machine learning based on an algorithm of RNN (LSTM), and estimates a word / phrase that appears following the one or more words / phrases from one or more words / phrases that appear in order from the head of the sentence. 142 is generated. The control unit 11 generates different language models 142 according to the type and clause of the contract. The control unit 11 stores the generated language models 142 of various types and clauses in the auxiliary storage unit 14. The control unit 11 ends the series of processes.

FIG. 8 is a flowchart illustrating an example of the processing procedure of the contract inspection process. Based on FIG. 8, the processing content of the inspection processing executed by the server 1 will be described.
The control unit 11 of the server 1 acquires a contract to be inspected from the terminal 2 (step S31). The control unit 11 refers to the category determination model 141 and executes a structured process for determining the type and clause of the acquired contract (step S32). The control unit 11 divides the sentence of each determined clause into words of a predetermined unit (step S33).

  Based on the difference between the model data (language model 142) corresponding to each clause and the text for each clause determined from the contract to be examined, the control unit 11 extracts the cautionary part of the contract to be examined (step) S34). Specifically, the control unit 11 uses the language model 142 described above to calculate the occurrence probability of each word that appears in the text of each clause, and based on the calculated occurrence probability, the difference from the learning contract. The phrase corresponding to is determined. As described above, the control unit 11 sequentially inputs each phrase into the RNN that is the language model 142 according to the arrangement order, and generates one or more words that appear in order from the beginning, Probability is calculated. The control unit 11 extracts words / phrases whose occurrence probabilities are equal to or lower than a predetermined threshold as caution points.

  The control unit 11 outputs the extracted word / phrase as a caution location to the terminal 2 (step S35). For example, the control unit 11 causes the terminal 2 to display a word / phrase corresponding to the caution location in a manner different from other words / phrases by color coding or the like. In step S <b> 36, the control unit 11 may also refer to the language model 142 and output the phrase correction candidates that are output as caution points. Further, the control unit 11 may output an example sentence of a clause that is not described in the contract to be examined with reference to the category discrimination model 141. The control unit 11 ends the series of processes.

  In the above description, the server 1 has structured the contract using the category discriminating model 141 prepared in advance. However, the input worker tags each sentence of the contract with information such as type and clause. For example, the contract may be structured manually.

  In the above description, the server 1 generates the language model 142 by machine learning, and extracts the caution location using the language model 142. However, the present embodiment is not limited to this. For example, the server 1 stores a simple contract template (text) as model data, performs text pattern matching, determines the difference between the contract to be inspected and the template contract, and extracts a point of caution. You may make it do. That is, the server 1 only needs to be able to determine the difference between the template contract and the contract to be inspected for each clause, and the processing content is not limited to an algorithm based on machine learning.

  In the above description, the server 1 performs both the learning process and the examination process of the contract. However, each process may be executed by a separate computer. For example, the server 1 may generate the language model 142, install the language model 142 data in the terminal 2, and the terminal 2 may inspect the contract using the language model 142. As described above, the learning device for learning the text of the contract and the inspection device for inspecting the contract may have different hardware configurations.

  As described above, according to the first embodiment, the contract to be inspected is divided for each clause, and the text of each clause is compared with the model data to extract the caution portion. By performing the processing separately for each clause, it is possible to appropriately extract a portion that is presumed to be an error or the like by taking advantage of the characteristics of the contract that is divided into a plurality of clauses and describes the contract contents.

  Further, according to the first embodiment, it is possible to accurately extract a point of caution by using the language model 142 (learned model) in which the order of words appearing in the clauses of the contract is learned.

  Further, according to the first embodiment, by using the language model 142, not only a caution location can be extracted but also a caution location correction candidate can be presented.

  Further, according to the first embodiment, a caution spot can be extracted with higher accuracy by performing a series of processes in consideration of the type of contract.

  Further, according to the first embodiment, it is possible to discriminate contract types and clauses on a rule basis based on keywords and to structure the contract.

  Further, according to the first embodiment, the feature amount of each sentence in the contract is calculated using an algorithm such as the tf-idf method, and the similarity is obtained, whereby the contract is preferably structured. be able to.

  Further, according to the first embodiment, not only a caution point is presented to the user, but also an example sentence of a clause that is not described in the contract can be presented to the user.

(Embodiment 2)
In the present embodiment, a description will be given of a mode in which a caution location is extracted from a contract to be inspected using a language model 142 that has learned a contract to be a template and a language model 142 that has learned a contract to be noted. . In addition, about the content which overlaps with Embodiment 1, the same code | symbol is attached | subjected and description is abbreviate | omitted.
FIG. 9 is an explanatory diagram showing an outline of the second embodiment. In FIG. 9, as in the first embodiment, the language model 142 (first model data) generated from the template contract and the required contract with a specific word (element) defined as a caution location are generated. Using the language model 142 (second model data) that has been made, the attention location is extracted from the contract to be inspected. The outline of the present embodiment will be described based on FIG.

  In the first embodiment, the mode in which the language model 142 is generated from the template contract that does not have the word corresponding to the caution portion, corresponding to the upper side of FIG. 9, and the caution portion is extracted has been described. However, when the attention part is extracted only from the language model 142, there is a possibility that the attention part may be extracted only by so-called phrases such as usage and arrangement of words, grammar, and the like, not the contract content itself. Therefore, there is a possibility of outputting a detection result that does not conform to the original meaning of detecting a defect in the contract contents.

  Therefore, in the present embodiment, the server 1 generates the language model 142 from the template contract that does not have the specific word / phrase defined as the caution location, and requires the caution agreement that includes the specific word / phrase defined as the caution location in advance. Based on the above, a language model 142 that has learned the habits that frequently appear in the contract is generated. When the server 1 extracts a caution location from the contract to be inspected, the server 1 extracts the caution location using two language models 142 for one clause.

  Specifically, the server 1 calculates the occurrence probability of each word / phrase in the contract from each language model 142. Thereby, as shown in the right side of FIG. 9, the server 1 calculates two occurrence probabilities for one word / phrase. Based on the occurrence probability calculated from each language model 142, the server 1 determines whether the word / phrase is a caution part corresponding to a difference from the template contract.

  For example, the server 1 has an occurrence probability calculated from the language model 142 of a template contract that does not have a specific word or phrase is equal to or less than a predetermined threshold and is calculated from the language model 142 of a cautionary contract that has a specific word or phrase. A word / phrase having a probability equal to or higher than a predetermined threshold is extracted as an attention place. Since the language model 142 of the contract requiring attention having a specific phrase is a learned model in which the wrinkles that frequently appear in the contract are learned, when the occurrence probability is calculated using the language model 142, the server 1 A word corresponding to a part is calculated with a high value in the same manner as other words. Therefore, by extracting a phrase whose occurrence probability calculated from the former language model 142 is equal to or less than the threshold and whose occurrence probability calculated from the latter language model 142 is equal to or more than the threshold, it is determined as a caution place only by wording. It is possible to accurately extract only the part that is presumed to be a trap of the contract contents.

FIG. 10 is a flowchart showing an example of the processing procedure of the contract document learning process according to the second embodiment. Based on FIG. 10, the contents of the contract learning process in the present embodiment will be described.
The control unit 11 of the server 1 acquires a contract to be a template and a contract to be noted (step S201). Specifically, the control unit 11 acquires a template contract that does not have a specific word (element) corresponding to the caution location and a caution agreement that has a specific word corresponding to the caution location. The specific phrase is a predetermined phrase defined as a habit that frequently appears when a contract is created. The control unit 11 obtains a template contract that does not include a word or phrase corresponding to 瑕疵 and a cautionary contract that includes a word or phrase corresponding to 瑕疵. The control part 11 transfers a process to step S12.

  After dividing the text of each clause for each template contract and cautionary contract (step S13), the control unit 11 separates the language model 142 (first and second language models) from each contract. Model data) is generated (step S202). That is, the control unit 11 constructs separate RNNs from a sentence that does not have a habit and a sentence that has a habit, even if they are sentences of the same type and clause. The control unit 11 ends the series of processes.

FIG. 11 is a flowchart illustrating an example of a processing procedure of contract inspection processing according to the second embodiment. Based on FIG. 11, the contents of the contract inspection process according to the present embodiment will be described.
After dividing the text of each clause included in the contract to be inspected into words of a predetermined unit (step S33), the control unit 11 of the server 1 executes the following processing. The control unit 11 uses the model data (first model data) generated from the above-described template contract and the model data (second data generated from the cautionary contract) for each clause specified from the contract to be inspected. The model data) is compared with each other to determine a difference, and a point of caution is extracted (step S221). Specifically, the control unit 11 calculates the occurrence probability of each word and phrase appearing in the contract to be examined based on the language model 142 generated from the template contract that does not have the specific word and phrase, Similarly, the probability of occurrence of each word is calculated from the language model 142 generated from the cautionary contract that the user has. The control unit 11 determines a difference according to the occurrence probability calculated from each language model 142, and extracts a caution location. For example, the control unit 11 has an occurrence probability calculated from the language model 142 of the template contract having a specific phrase that is equal to or higher than a predetermined threshold and is calculated from the language model 142 of the template contract having no specific phrase. A word or phrase having a probability equal to or less than a predetermined threshold is extracted as a caution location. The control part 11 transfers a process to step S35.

  In the above description, the server 1 learns a cautionary contract having a specific word / phrase specified as a caution location and generates the language model 142 (second model data). It is not limited to this. For example, the server 1 defines a contract that does not contain important keywords in the contract and lacks important matters as a cautionary contract, and learns the contract to generate the language model 142. It is good. As a result, a warning can be output for a contract that lacks important matters. In addition, for example, the server 1 specifies a contract that does not have a flaw in each word but has the wrong contents of the entire document, such as the order of description of each sentence, as a cautionary contract, and learns the contract. The language model 142 may be generated. Accordingly, the server 1 can learn the flow of the entire contract and output a warning. As described above, the contract that the server 1 learns is a contract that requires attention, and is not limited to a contract having a specific word or phrase.

  As described above, according to the second embodiment, it is possible to accurately extract the defects of the contract content itself.

(Embodiment 3)
In the present embodiment, a mode will be described in which the entire clause is output as a caution location according to the number of caution locations extracted from the text of each clause.
FIG. 12 is an explanatory diagram showing an outline of the third embodiment. Similarly to the first embodiment, the server 1 according to the present embodiment refers to the language model 142 and extracts caution points from each clause of the contract to be inspected, and outputs them to the terminal 2. Further, in the present embodiment, the server 1 outputs a clause itself having many caution locations as a caution location according to the number of caution locations in each clause.

  In the example shown on the left side of FIG. 12, the clause of “payment method and timing” is described in the “non-disclosure agreement”, but the non-disclosure agreement should originally have no clause relating to payment of money. However, since the user described the above clause in the contract because the user mistakes it for another contract, the server 1 extracts a large number of points of caution from the text portion of the clause. In the present embodiment, the server 1 notifies the user of the clause from which a large number of points of caution are extracted as a clause that should not normally be described.

  For example, as shown on the right side of FIG. 12, the server 1 causes the terminal 2 to display the entire clause as a warning location. For example, the terminal 2 displays a corresponding clause in a manner different from other clauses by a method such as color coding. As a result, the user can easily grasp the clause that should not normally be written in the contract.

  In the above description, the caution portion is output in units of clauses. However, for example, the server 1 may perform the above-described processing in units of sentences or paragraphs. That is, the server 1 only needs to be able to present a sentence in which a plurality of caution points are detected to the user, and the unit of the sentence is not particularly limited.

FIG. 13 is a flowchart illustrating an example of a processing procedure of contract inspection processing according to the third embodiment. Based on FIG. 13, the contents of the contract inspection process according to the present embodiment will be described.
After extracting the caution part from the contract to be inspected (step S34), the control unit 11 of the server 1 executes the following processing. The control unit 11 determines whether or not there is a clause having a predetermined number or more of words / phrases corresponding to the caution location (step S301). When it is determined that there is no clause having a predetermined number or more of words / phrases corresponding to the cautionary part (S301: NO), the control unit 11 proceeds to step S35.

  When it is determined that there is a clause having a predetermined number or more of words / phrases corresponding to the caution location (S301: YES), the control unit 11 outputs the entire corresponding clause as the caution location (step S302). For example, as shown in FIG. 12, the control unit 11 causes the terminal 2 to display the corresponding clause in a different display mode such as color-coding the other clause from other clauses. The control unit 11 ends the series of processes.

  As described above, according to the third embodiment, it is possible to present a clause that should not be normally described in the contract to the user and encourage reconsideration.

(Embodiment 4)
FIG. 14 is a functional block diagram showing the operation of the server 1 in the above-described form. When the control unit 11 executes the program P, the server 1 operates as follows.
The storage unit 1401 stores model data for each of a plurality of clauses. The acquisition unit 1402 acquires a contract. The determination unit 1403 determines a portion corresponding to the clause from the acquired contract. The extraction unit 1404 extracts a caution part of the contract based on a difference between the model data corresponding to each clause and the sentence for each clause determined from the contract. The output unit 1405 outputs the caution location.

  The fourth embodiment is as described above, and the other parts are the same as those of the first to third embodiments. Therefore, the corresponding parts are denoted by the same reference numerals, and detailed description thereof is omitted.

  The embodiments disclosed herein are illustrative in all respects and should not be considered restrictive. The scope of the present invention is defined by the terms of the claims, rather than the meanings described above, and is intended to include any modifications within the scope and meaning equivalent to the terms of the claims.

1 server (information processing device, inspection device, learning device)
DESCRIPTION OF SYMBOLS 11 Control part 12 Main memory part 13 Communication part 14 Auxiliary memory part P Program 141 Category discrimination | determination model 142 Language model 2 Terminal

Claims (13)

A storage unit for storing model data of each of the plurality of clauses;
An acquisition unit for acquiring a contract;
A discriminator for discriminating a portion corresponding to the clause from the acquired contract;
An extraction unit that extracts a caution part of the contract based on a difference between the model data corresponding to each clause and the sentence for each clause determined from the contract;
An inspection apparatus comprising: an output unit that outputs the attention location. A division unit that divides the sentence for each clause determined from the contract into a plurality of elements that are characters or character strings of a predetermined unit,
The model data is a learned model obtained by learning the elements appearing next to each element in the order of the sentences for each clause of the contract.
The extraction unit includes:
With reference to the model data, the occurrence probability of each element of the sentence divided by the dividing unit,
The inspection apparatus according to claim 1, wherein the difference is extracted according to the calculated occurrence probability. The said output part refers to the said model data, and when the said attention location is output, the said element with the highest occurrence probability is output as a correction candidate of the said attention location. Inspection device. The storage unit stores, for each clause, first model data learned from a contract to be a template and second model data learned from a contract to be noted;
The inspection apparatus according to claim 2 or 3, wherein the extraction unit extracts the caution location of the sentence for each clause based on the difference between the first and second model data. The storage unit stores the model data corresponding to a type,
The determination unit determines the type of the contract,
The inspection device according to any one of claims 1 to 4, wherein the extraction unit extracts the caution location based on the model data corresponding to a type of the contract. The storage unit stores keywords corresponding to the plurality of clauses,
The inspection device according to claim 1, wherein the determination unit determines the clause based on the keyword included in the sentence. The storage unit stores the feature amount of the sentence according to the appearance frequency of each word for each clause.
The discrimination unit
Based on the appearance frequency of each word included in the sentence of each clause, the feature amount of the sentence is calculated,
Calculating the similarity between the calculated feature amount of the sentence and the feature amount stored in the storage unit;
The inspection apparatus according to claim 1, wherein the clause is determined according to the calculated similarity. The output unit refers to model data of each of the plurality of clauses, determines the clauses that are not described in the contract, and outputs a sentence example of the clauses. The inspection device according to any one of the above. A specifying unit for specifying a sentence of the clause having a predetermined number or more of the differences;
The inspection apparatus according to claim 1, wherein the output unit outputs the entire sentence of the specified clause as the caution location. Get a contract,
From the acquired contract, determine portions corresponding to a plurality of clauses included in the contract,
With reference to a storage unit storing model data of each of the plurality of clauses, the contract document is based on a difference between the model data corresponding to each clause and the sentence for each clause determined from the contract document. Extract the notes
An inspection method characterized by causing a computer to execute a process of outputting the caution portion. Get a contract,
From the acquired contract, determine portions corresponding to a plurality of clauses included in the contract,
With reference to a storage unit storing model data of each of the plurality of clauses, the contract document is based on a difference between the model data corresponding to each clause and the sentence for each clause determined from the contract document. Extract the notes
A program for causing a computer to execute a process of outputting the caution area. An acquisition unit for acquiring a contract;
A division unit that divides a sentence for each clause included in the contract into a plurality of elements that are characters or character strings of a predetermined unit, and learns the elements that appear next to each element in order in the sentence for each clause. A learning device comprising: a generating unit that generates the model data. The acquisition unit acquires a contract to be a template and a contract to be noted,
The learning device according to claim 12, wherein the generation unit generates first and second model data from a contract to be used as the template and a contract to be noted.

Images