JP2018018341A - Information processing device, information processing method and program - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide an information processing device or the like capable of updating a rule to be used for processing while successively processing input individual data.SOLUTION: The information processing device includes an acquisition unit for acquiring input individual data 28, a conversion unit for converting the input individual data 28 acquired by the acquisition unit on the basis of a rule, a storage unit for storing the input individual data 28 acquired by the acquisition unit, a generation unit for generating a new rule on the basis of a plurality of input individual data 28 stored by the storage unit, and an update unit for updating the rule used by the conversion unit to the new rule generated by the generation unit.SELECTED DRAWING: Figure 9

Description

  The present invention relates to an information processing apparatus, an information processing method, and a program.

  A method of anonymizing a newly acquired input card by calculating a rule for anonymizing so as to satisfy k-anonymity with respect to an input card acquired in the past has been proposed (Patent Document 1 discloses a patent). Reference 3).

JP2013-80375A US Patent Application Publication No. 2002/169793 JP-T 2006-5122012

  Patent Documents 1 to 3 do not disclose a method for updating rules used for processing in parallel with sequential processing of input pieces.

  In one aspect, an object is to provide an information processing apparatus or the like that can update rules used for processing while sequentially processing input pieces.

  The information processing apparatus stores an acquisition unit that acquires an input piece, a conversion unit that converts the input piece acquired by the acquisition unit based on a rule, and the input piece acquired by the acquisition unit An accumulation unit, a generation unit that generates a new rule based on the plurality of input pieces accumulated by the storage unit, and an update that updates a rule used by the conversion unit to a new rule generated by the generation unit A part.

  In one aspect, it is possible to provide an information processing apparatus or the like that can update rules used for processing while sequentially processing input pieces.

It is explanatory drawing which shows the structure of an information processing system. It is explanatory drawing which shows the outline | summary of a process. It is explanatory drawing which shows the example of an input piece. It is explanatory drawing which shows the record layout of storage DB. It is explanatory drawing which shows the record layout of rule DB. It is explanatory drawing which shows the example of an output piece. It is explanatory drawing which shows the 2nd example of rule DB. It is explanatory drawing which shows the 2nd example of an output piece. It is a time chart explaining the outline | summary of a process. It is explanatory drawing which shows the 3rd example of rule DB. It is explanatory drawing explaining a conversion result. It is a flowchart which shows the flow of a rule production | generation process. It is a flowchart which shows the flow of a process of a subroutine of rule creation. It is a flowchart which shows the flow of sequential data processing. It is a flowchart which shows the flow of a process of the subroutine of a conversion process. FIG. 6 is an explanatory diagram illustrating a configuration of an information processing system according to a second embodiment. 6 is a flowchart illustrating a flow of processing according to the second embodiment. 12 is an explanatory diagram for explaining a conversion result of a third embodiment. FIG. 12 is an explanatory diagram illustrating an example of a rule DB according to Embodiment 3. FIG. FIG. 10 is a functional block diagram illustrating an operation of the information processing apparatus according to the fourth embodiment. FIG. 10 is an explanatory diagram illustrating a configuration of an information processing system according to a fifth embodiment.

[Embodiment 1]
FIG. 1 is an explanatory diagram illustrating a configuration of the information processing system 10. The information processing system 10 includes a server 11, a first client 21, and a second client 25 that are examples of the information processing apparatus according to the present embodiment. The server 11, the first client 21, and the second client 25 are connected via a network such as the Internet, a public communication line, or a LAN (Local Area Network).

  The server 11 includes a server CPU (Central Processing Unit) 12, a main storage device 13, an auxiliary storage device 14, a communication unit 15, and a bus. The server 11 according to the present embodiment performs sequential data processing for converting the input vote 28 into an anonymized output vote 29 and generation of rules used for the conversion. The server 11 of the present embodiment is an information device such as a general-purpose personal computer or a large computer. Further, the server 11 of the present embodiment may be a virtual machine that operates on a large computer.

  The server CPU 12 is an arithmetic control device that executes a program according to the present embodiment. As the server CPU 12, one or a plurality of CPUs, a multi-core CPU, or the like is used. The server CPU 12 is connected to each hardware unit constituting the server 11 via a bus.

  The main storage device 13 is a storage device such as an SRAM (Static Random Access Memory), a DRAM (Dynamic Random Access Memory), or a flash memory. The main storage device 13 temporarily stores information necessary during processing performed by the server CPU 12 and a program being executed by the server CPU 12.

  The auxiliary storage device 14 is a storage device such as an SRAM, a flash memory, a hard disk, or a magnetic tape. The auxiliary storage device 14 stores a program to be executed by the server CPU 12, a storage DB (Data Base) 31, a rule DB 32, and various types of information necessary for executing the program. The communication unit 15 is an interface that performs communication with a network. The accumulation DB 31 and the rule DB 32 may be stored in another storage device connected to the server 11 via a network or the like.

  The accumulation DB 31 is a DB that accumulates input pieces 28 acquired from the network. The rule DB 32 is a DB that records rules used when the input pieces 28 are sequentially converted into the output pieces 29. In the present embodiment, the server CPU 12 anonymizes by converting the input vote 28 to the output vote 29 based on the rule DB 32. Details of the accumulation DB 31 and the rule DB 32 will be described later.

  The second client 25 is a client that sequentially acquires the input pieces 28 and sends them to the network. The second client 25 is an information terminal such as a personal computer, a tablet, or a smartphone used by an information terminal installed in a store or the like and a general consumer. In the following description, a user who operates the second client 25 is referred to as a second user.

  The input card 28 is obtained from, for example, member registration on a website, transaction record of mail order sales, point grant record of a point card, and the like. The input pieces 28 are sequentially sent from the second client 25 to the network in a predetermined format. There is a possibility that the personal information 28 includes information related to individuals.

  The first client 21 is a client used by a user who utilizes the output individual vote 29 for marketing, for example. The first client 21 of the present embodiment uses an information device such as a general-purpose personal computer or a large computer. In the following description, a user who operates the first client 21 is referred to as a first user. The first client 21 sequentially receives the output vote 29 in which the input vote 28 is anonymized by the server CPU 12.

  The first client 21 and the second client 25 include a CPU, a main storage device, an auxiliary storage device, and a communication unit, as with the server 11. Further, the first client 21 and the second client 25 include an input interface such as a keyboard, a touch panel, and a mouse, and an output interface such as a liquid crystal display, an organic EL display, and a print. The internal configurations of the first client 21 and the second client 25 are not shown.

  FIG. 2 is an explanatory diagram showing an outline of the processing. The server CPU 12 of this embodiment performs in parallel the generation of a rule for converting the input vote 28 and the sequential data processing for converting the input vote 28 to the output vote 29 based on the rule. The processing flow of rule generation and sequential data processing will be described later. The time required for sequential data processing of each input piece 28 is significantly shorter than the time required for rule generation.

  The server CPU 12 generates a rule based on the data of the input votes 28 accumulated in the accumulation DB 31. When the input piece 28 is received during the generation of the rule, the server CPU 12 preferentially executes sequential data processing for converting the input piece 28 into the output piece 29. After the processing of the input individual card 28 is completed, the server CPU 12 resumes the rule generation process.

  The server CPU 12 may execute rule generation processing in parallel during sequential data processing. For example, the load on the server CPU 12 is relatively small in the process of accumulating the input personal records 28 in the storage DB 31 and the process of transmitting the output personal records 29 to the network. In this way, when the load on the server CPU 12 is relatively small, even if rule generation processing is performed in parallel, the speed of sequential data processing is not adversely affected.

  The server CPU 12 updates the rule recorded in the rule DB 32 to the newly generated rule. The server CPU 12 sequentially performs data processing using the new rule for the input vote 28 received after the rule DB 32 is updated.

  By repeating the above processing, the server CPU 12 newly generates and updates a rule used for the processing based on the processing for converting the input vote 28 into the output vote 29 and the input vote 28 stored in the storage DB 31. The process to be executed is executed in parallel.

  FIG. 3 is an explanatory diagram showing an example of the input piece 28. One line in FIG. 3 shows one input card 28 and an ID (IDentifier). The individual vote is data handled as one lump such as membership registration information for one person or a record of one transaction. FIG. 3 shows an individual vote including three items, such as a zip code, year of birth, and gender, as an example. FIG. 3 shows an example in which only the first three digits of the postal code are recorded.

  In the leftmost column of FIG. 3, IDs for identifying individual votes are shown for explanation. In the present embodiment, an explanation will be given by assigning IDs A to H in the order in which the server CPU 12 received individual votes from the network. In addition to the items shown in FIG. 3, the individual vote may include various items relating to individuals such as an address, name, telephone number, e-mail address, family structure, purchased product, and payment method.

  FIG. 4 is an explanatory diagram showing a record layout of the storage DB 31. The accumulation DB 31 is a DB that associates the input individual form 28 with use / non-use for rule generation. The accumulation DB 31 has an input piece field and a use field. The input slip field includes a zip code field, a birth year field, and a gender field. The storage DB 31 has one record for one input piece 28 stored. In FIG. 4, for the sake of explanation, the ID of the input piece is shown in the leftmost column.

  In each field of the input slip field, each data included in the input slip 28 is recorded. In the use field, whether or not it has been used to generate a rule for converting the input slip 28 is recorded.

  The server CPU 12 does not accumulate in the accumulation DB 31 the individual vote determined not to be used for generating the rule for converting the input individual vote 28. For this reason, the individual forms with IDs D and G are not recorded in the storage DB 31. The determination of individual votes accumulated in the accumulation DB 31 and non-accumulated individual votes will be described later.

  FIG. 5 is an explanatory diagram showing a record layout of the rule DB 32. The rule DB 32 is a DB that records a rule used when the input piece 28 is converted into the output piece 29. The rule DB 32 is No. A field, an input vote field, and an output vote field. The input item field and the output item field include a zip code field, a birth year field, and a gender field, respectively. The rule DB 32 has one record for one rule used for conversion.

  No. In the field, the order for determining whether or not the rule is applicable is recorded. In this embodiment, no. It is determined whether or not it is possible to apply sequentially from the record with the smallest number recorded in the field. In the input individual field, conditions for applying the record are recorded. In the output form field, a piece to be output when a record is applied is recorded.

  This will be described more specifically. No. A record of 1 indicates a rule for conversion to an output vote 29 of “198, 20, female” when the input vote 28 is “198, 20, female”. Similarly, no. The record of 2 indicates a rule for conversion to an output vote 29 of “198, 50, male” when the input vote 28 is “198, 50, male”. No. The record No. 3 indicates a rule for converting to an output vote 29 of “*, *, *” when the input vote 28 does not match the input vote field of any other record.

  Here, “*” means that specific data of each item of the input card 28 is hidden. In the following description, “*” is referred to as a generalized code. Similarly, individual votes “*, *, *” in which all items are generalized codes “*” are referred to as generalized individual votes. In addition, the process of replacing the individual vote item with the generalized code “*” is referred to as a generalized process.

  Through the generalization process, a plurality of input votes 28 having different contents are converted into the same output vote 29. By processing the input vote 28 in this way, the input vote 28 can be converted into an output vote 29 having anonymity with a predetermined condition.

  FIG. 6 is an explanatory diagram showing an example of the output individual sheet 29. One line in FIG. 6 shows an output form 29 obtained by converting the input form 28 shown in one line in FIG. 3 according to the rules shown in FIG. The ID shown in the leftmost column of FIG. 6 is a symbol for identifying each individual vote for explanation. The ID given to the output card 29 is identical to the ID given to the input card 28. The conversion of the input piece 28 will be described with reference to FIGS. 3, 5, and 6.

  The input slips 28 with IDs A and G are the No. of the rule shown in FIG. It matches the input individual field of 1 record. Therefore, no. One record is applied, and the output vote 29 is “198, 20, woman”. Input slips 28 with IDs B, C, and D are registered in the No. of rule shown in FIG. It matches the input individual field of record 2. Therefore, no. 2 records are applied, and the output vote 29 is “198, 50, male”. Input slips 28 with IDs E, F, and H do not match the input slip fields of records other than No. 3 in the rule shown in FIG. Therefore, no. 3 records are applied, and the output votes 29 are generalized votes “*, *, *”.

  FIG. 7 is an explanatory diagram showing a second example of the rule DB 32. The record layout of the rule DB 32 shown in FIG. 7 is the same as the record layout of the rule DB 32 described with reference to FIG. No. In the record 1, “−” is recorded in the gender field of the input individual field. “-” Indicates that the record is applied regardless of the contents of the item in the input piece 28.

  This will be described more specifically. No. For the record of 1, when the postal code of the input card 28 is “198” and the year of birth is “20”, the rule for converting to the output card 29 of “198, 20, *” regardless of gender data. Show. No. 2 and no. Since the record 3 is the same as that in FIG.

  FIG. 8 is an explanatory diagram showing a second example of the output individual sheet 29. One line of FIG. 8 shows an output form 29 obtained by converting the input form 28 shown in one line of FIG. 3 according to the rules shown in FIG. The ID shown in the leftmost column of FIG. 8 is a symbol for identifying each individual vote for explanation. The ID given to the output card 29 is identical to the ID given to the input card 28. The conversion of the input piece 28 will be described with reference to FIGS. 3, 7, and 8.

  The input slips 28 with IDs A, G and H are the rule numbers shown in FIG. It matches the input individual field of 1 record. Therefore, no. One record is applied, and the output vote 29 is “198, 20, *”. Here, the input votes 28 of A and G whose sex is “female” and the input slips 28 of H whose sex is “male” are converted into the same output vote 29.

  The input slips 28 with IDs B, C and D are the No. of the rule shown in FIG. It matches the input individual field of record 2. Therefore, no. 2 records are applied, and the output vote 29 is “198, 50, male”. Input slips 28 with IDs E and F do not match the input slip fields of records other than No. 3 in the rule shown in FIG. Therefore, no. 3 records are applied, and the output votes 29 are generalized votes “*, *, *”.

  As shown in FIGS. 6 and 8, even when the same input form 28 is input, if the contents of the rule DB 32 are different, they are converted into different output forms 29. It is desirable that the rule DB 32 be appropriately adjusted in accordance with a change in the tendency of the input individual 28 and a change in needs of the first user who uses the converted individual vote.

  FIG. 9 is a time chart for explaining the outline of the processing. FIG. 10 is an explanatory diagram illustrating a third example of the rule DB 32. FIG. 11 is an explanatory diagram for explaining the conversion result. The processing of the server CPU 12 of this embodiment will be described using FIGS. 9 to 11.

  The horizontal axis of FIGS. 9S to 9W is time. FIG. 9S shows the timing at which the server CPU 12 receives the input piece 28. FIG. 9T shows the timing at which the server CPU 12 transmits the output vote 29. FIG. 9U shows the timing at which the server CPU 12 stores the input vote 28 in the storage DB 31.

  Each time the server CPU 12 receives the input vote 28, the server CPU 12 performs sequential data processing to convert the output vote 29 based on the rules recorded in the rule DB 32. The time required for the process of converting the input individual 28 into the output individual 29 and the process of accumulating the input individual 28 in the storage DB 31 is short. Therefore, on the time chart shown in FIG. 9, the reception of the input pieces 28, the output of the output pieces 29, and the accumulation of the input pieces 28 are performed at substantially the same time.

  FIG. 9V shows the time for the server CPU 12 to generate a rule for converting the input piece 28 into the output piece 29 with a white arrow. FIG. 9W shows a change in the rule DB 32 used when the server CPU 12 converts the input vote 28 into the output vote 29.

  FIG. 10 shows the rule X1 first recorded in the rule DB 32. The rule X1 indicates a rule for converting all input votes 28 into generalized votes “*, *, *”. FIG. 11 shows the rules used for converting the input votes 28 with IDs A to H and the output vote 29 obtained by converting each input vote 28 by the server CPU 12.

  An example of processing performed by the server CPU 12 of the present embodiment will be described along the time chart shown in FIG. The server CPU 12 receives the input slips 28 with IDs A and B at the time when the rule X1 is used as shown in FIG. 9W. The server CPU 12 converts each input piece 28 into an output piece 29 of A1 and B1 and outputs it. As shown in FIG. 11, since the rule X1 shown in FIG. 10 is applied to the input pieces 28 having IDs A and B, the output pieces 29 are generalized pieces “*, *, *”.

  Further, the server CPU 12 accumulates the input pieces 28 of A and B in the accumulation DB 31 as shown in FIG. 9U. The server CPU 12 records “not yet” in the use field of each record to be accumulated.

  After the input piece 28 with ID B is accumulated in the accumulation DB 31, as shown in FIG. 9U, the server CPU 12 acquires accumulated data from the accumulation DB 31, and starts generating a new rule X2 used for conversion. . The server CPU 12 changes the use field of the acquired record in the storage DB 31 to “Done”. The generation of the rule is a complicated process and takes time as shown by the white arrow in FIG. 9V. Details of the rule generation will be described later.

  The server CPU 12 receives the input card 28 whose ID is C during the process of generating the rule X2. The server CPU 12 uses the rule X1 to convert it into an output piece 29 of C1 and outputs it. As shown in FIG. 11, the output pieces 29 are generalized pieces “*, *, *”. The server CPU 12 stores the input piece 28 with ID C in the storage DB 31.

  After the generation of the rule X2 is completed, the CPU 12 updates the contents of the rule DB 32 from the rule X1 to the rule X2. Thereafter, the server CPU 12 uses the rule X2 for conversion of the input card 28. The rule X2 is the rule described with reference to FIG. The server CPU 12 acquires accumulated data from the accumulation DB 31 and starts generating a new rule X3 used for conversion.

  If there is no record recorded in the usage field in the storage DB 31 in the storage DB 31, the server CPU 12 does not start generating rules until a new record is added to the storage DB 31. The server CPU 12 may start generating a rule when the number of records in which “unused” is recorded in the use field reaches a predetermined number. The server CPU 12 may start rule generation after a predetermined time has elapsed after rule generation is completed. The server CPU 12 may start generating rules at a predetermined time, for example, every day at 0:00.

  The server CPU 12 receives the input vote 28 with IDs D, E, F, G and H at the time of using the rule X2, and converts it into an output vote 29 with D2, E2, F2, G2 and H2. Output. Since the input card 28 with the ID “D” is “198, 50, male”, the server CPU 12 has No. 2 shown in FIG. 2 records are applied. As a result, the server CPU 12 outputs an output vote 29 of “198, 50, male”. Since the input card 28 whose ID is G is “198, 20, female”, the server CPU 12 has No. 2 shown in FIG. Apply 1 record. As a result, the server CPU 12 outputs an output vote 29 of “198, 20, woman”. For input slips 28 whose IDs are E, F, and H, the server CPU 12 receives No. 2 shown in FIG. 3 records are applied. As a result, the server CPU 12 outputs generalized individual votes “*, *, *”.

  Further, the server CPU 12 accumulates input pieces 28 with IDs E, F and H in the accumulation DB 31. The reason why the server CPU 12 does not store the individual votes having IDs D and G in the storage DB 31 will be described later.

  After the generation of the rule X3 is completed, the CPU 12 updates the contents of the rule DB 32 from the rule X2 to the rule X3. Thereafter, the server CPU 12 uses the rule X3 for converting the input card 28. The server CPU 12 acquires accumulated data from the accumulation DB 31 and starts generating a new rule X4 used for conversion.

  As described above, the server CPU 12 receives the input vote 28, converts it into the output vote 29 based on the rule, and sequentially outputs the new rule based on the accumulated input vote 28. Generate.

  A rule generated by the server CPU 12 in this embodiment will be described. First, anonymity will be described. A state in which there are k or more individual votes of the same content, including the individual votes themselves, in any individual vote is called k-anonymity. Here, k is an integer of 2 or more. If k-anonymity is ensured, it is not possible to narrow down and specify individuals associated with individual votes to less than k people.

  The server CPU 12 according to the present embodiment generates a rule for converting the input vote 28 into an output vote 29 having anonymity k = 2. Specifically, when the combination of data recorded in each item is the same as the input form 28 acquired in the past, an output form 29 having the same data as the input form 28 is output. On the other hand, if the combination of the data recorded in each item is different from any input card 28 acquired in the past, the generalized card “*, *, *” is output.

  Therefore, the server CPU 12 generates the rule DB 32 having the same data as the input card 28 stored in the storage DB 31 in the input card field and the output card field. The server CPU 12 deletes the duplicate record when the record having the same input card field is recorded in the rule DB 32 in duplicate.

  When the input card 28 and the output card 29 are the same, the input card 28 having the same data is already stored in the storage DB 31. Accordingly, the server CPU 12 does not store the input piece 28 in the storage DB 31. As described with reference to FIG. 11, the input votes 28 with IDs D and G are converted into output slips 29 having the same contents, so that the server CPU 12 stores these input slips 28 in the storage DB 31. do not do.

  The rule DB 32 described above is an example. The server CPU 12 may generate a rule for converting the input vote 28 to the output vote 29 so as to have k-anonymity of k = 3 or more. The server CPU 12 may generate a rule for converting the input vote 28 to the output vote 29 so as to have, for example, Pk-anonymity. Pk-anonymity means a state where the possibility that an individual can be identified from an individual vote is less than 1 / k.

  The rule X1 to be used first may be a rule generated in advance based on a large number of input votes 28 collected in advance.

  FIG. 12 is a flowchart showing the flow of rule generation processing. The program shown in FIG. 12 is a program that performs processing for generating the conversion rule shown in FIG. 9V. The process flow of the program according to the present embodiment will be described with reference to FIG.

  The server CPU 12 acquires a notification instructing the start of the rule generation process (step S500). The notification is, for example, a signal or interrupt signal received by the server CPU 12 via the network. A clock built in the server 11 may generate a notification at a predetermined time or every predetermined time interval.

  The server CPU 12 acquires the number of records in which “not yet” is recorded in the use field from the accumulation DB 31 (step S501). The server CPU 12 determines whether or not rule generation is to be started (step S502). For example, the server CPU 12 determines to start generating the rule when the number acquired in step S501 is 1 or more.

  If it is determined not to start generation (NO in step S502), the server CPU 12 returns to step S500. If it is determined that generation is to be started (YES in step S502), the server CPU 12 activates a rule creation subroutine (step S503). The rule creation subroutine is a subroutine for creating a rule to be recorded in the rule DB 32 based on the input individual sheets 28 accumulated in the accumulation DB 31. The processing flow of the rule creation subroutine will be described later.

  The server CPU 12 updates the rule DB 32 with the rules created in step S503 (step S504). The server CPU 12 determines whether or not to end the process (step S505). The case where the process is ended is a case where an input for ending the process for generating the processing rule is received via the network, for example.

  If it is determined not to end the process (NO in step S505), the server CPU 12 returns to step S500. If it is determined to end the process (YES in step S505), the server CPU 12 ends the process.

  FIG. 13 is a flowchart showing a flow of processing of a rule creation subroutine. The rule creation subroutine is a subroutine for creating a rule to be recorded in the rule DB 32 based on the input individual sheets 28 accumulated in the accumulation DB 31. The flow of the rule creation subroutine will be described with reference to FIG.

  The server CPU 12 acquires data used for generating rules from the storage DB 31 (step S511). Specifically, the server CPU 12 obtains the data recorded in the input card field of each record recorded as “unused” in the use field from the storage DB 31 and stores it in the auxiliary storage device 14 or the main storage device 13. . The server CPU 12 changes the use field of the record in the storage DB 31 to “Done”.

  The server CPU 12 copies the rule DB 32 to the auxiliary storage device 14 or the main storage device 13 (step S512). Thereafter, the server CPU 12 executes processing using the rule DB 32 copied in step S512.

  The server CPU 12 sets the counter I to the initial value 1 (step S513). The server CPU 12 sets the counter J to the initial value 1 (step S514).

  The server CPU 12 determines whether or not the I-th input slip 28 acquired in step S511 matches the input slip field of the J-th record in the copied rule DB 32 (step S515). If it is determined that they do not match (NO in step S515), the server CPU 12 adds a new record to the copied rule DB 32 (step S516).

  Specifically, the server CPU 12 adds a record immediately before the last record in the copied rule DB 32. The server CPU 12 records the data of the I-th input card 28 in the input card field and the output card field of the added record. The server CPU 12 changes the No. of the added record. No. of field and last record. Record the number in the field by serial number.

  If it is determined that they match (YES in step S515), the server CPU 12 determines whether or not the processing of all the records in the copied rule DB 32 has been completed (step S517). If it is determined that the processing has not ended (NO in step S517), the server CPU 12 adds 1 to the counter J (step S518). The server CPU 12 returns to step S515.

  If it is determined that all the records in the rule DB 32 have been processed (YES in step S517) and after step S516, the server CPU 12 determines whether or not the processing of all input votes 28 acquired in step S511 has ended. Is determined (step S519). If it is determined that the process has not ended (NO in step S519), the server CPU 12 adds 1 to the counter I (step S520). The server CPU 12 returns to step S514. When it is determined that the process is finished (YES in step S519), the server CPU 12 finishes the process.

  The rule creation subroutine described with reference to FIG. 13 is an example. It is desirable to use a subroutine that implements an algorithm for creating rules according to the needs of the first user.

  The rule creation subroutine may be a subroutine that generates a rule for converting the input vote 28 to the output vote 29 so as to have k-anonymity of k = 3 or more. In this case, the server CPU 12 creates a new rule DB 32 by using the input pieces stored in the storage DB 31 without using a copy of the existing rule DB 32.

  The rule creation subroutine may be, for example, a subroutine that generates a rule for converting the input vote 28 to the output vote 29 so as to have Pk-anonymity.

  FIG. 14 is a flowchart showing the flow of sequential data processing. The program shown in FIG. 14 is a process that is sequentially executed every time the server CPU 12 receives the input card 28 from the network. The processing flow of the program according to the present embodiment will be described with reference to FIG.

  The server CPU 12 starts a conversion processing subroutine (step S532). The conversion processing subroutine is a subroutine for converting the input vote 28 into the output vote 29 based on the rules recorded in the rule DB 32. The processing flow of the conversion subroutine will be described later.

  The server CPU 12 transmits the output piece 29 to the network (step S533). The server CPU 12 determines whether or not the input piece 28 and the output piece 29 match (step S534). If it is determined that they do not match (NO in step S534), the server CPU 12 accumulates the input piece 28 in the accumulation DB 31 (step S535). Specifically, the server CPU 12 adds a new record to the storage DB 31. The server CPU 12 records the received data of the input card 28 in the input card field. The server CPU 12 records “not yet” in the use field.

  If it is determined that they match (YES in step S534) and after step S535 ends, the server CPU 12 ends the process.

  FIG. 15 is a flowchart showing the flow of the conversion processing subroutine. The conversion processing subroutine is a subroutine for converting the input vote 28 into the output vote 29 based on the rules recorded in the rule DB 32.

  The server CPU 12 sets the counter I to the initial value 1 (step S545). The server CPU 12 determines whether to apply the I-th record of the rule DB 32 to the input card 28 (step S542). Specifically, the server CPU 12 determines that the record is applied when the input slip 28 matches the data recorded in the input slip field of the I-th record in the rule DB 32.

  If it is determined not to apply (NO in step S542), the server CPU 12 adds 1 to the counter I (step S543). The server CPU 12 returns to step S542. If it is determined to be applied (YES in step S542), the server CPU 12 converts the input vote 28 and creates an output vote 29 (step S544). Specifically, the server CPU 12 sets the data recorded in the output card field of the I-th record of the rule DB 32 as the data of the output card 29. Thereafter, the server CPU 12 ends the process.

  According to the present embodiment, it is possible to provide the information processing system 10 that updates the rules used for processing while outputting the output votes 29 that are anonymized by sequentially processing the input tickets 28. Therefore, the first user can receive the anonymized output vote 29 every time the input vote 28 is generated and use it for marketing activities and the like.

  Since the rules used for conversion of the input card 28 are updated as needed, anonymization can be appropriately performed even when the tendency of the input card 28 changes.

  As described above, the rule creation subroutine described with reference to FIG. 13 is an example. It is desirable to use a subroutine that implements an algorithm for creating rules according to the needs of the first user.

  It is desirable that the input DB 28 is stored in the storage DB 31 according to an algorithm for creating a rule. Instead of performing the determination in step S534, all the input pieces 28 may be stored in the storage DB 31. After a predetermined number of input votes 28 are recorded in the storage DB 31, the old input tickets 28 may be deleted sequentially to keep the number of records stored in the storage DB 31 constant.

  The storage DB 31 may be provided with a field for recording the date and time when the input pieces 28 are stored, and a record after a predetermined time may be deleted after storage. The record in which the input slip 28 is acquired in step S511 may be deleted without providing the use field in the storage DB 31. The server CPU 12 may record only some of the items recorded in the input piece 28 in the storage DB 31.

[Embodiment 2]
The second embodiment relates to an information processing system 10 that performs rule generation and sequential data processing with different CPUs. Note that description of portions common to the first embodiment is omitted.

  FIG. 16 is an explanatory diagram illustrating a configuration of the information processing system 10 according to the second embodiment. The information processing system 10 includes a server 11, a conversion server 18, a first client 21, and a second client 25. The server 11, the conversion server 18, the first client 21, and the second client 25 are connected via a network.

  The conversion server 18 is a server that acquires the input piece 28, converts it into an output piece 29, and outputs it. The conversion server 18 of the present embodiment is an information device such as a general-purpose personal computer or a large computer. Further, the server 11 and the conversion server 18 of the present embodiment may be virtual machines that operate on the same hardware. The conversion server 18 is an example of a conversion unit of the present embodiment.

  Similar to the server 11, the conversion server 18 includes a CPU, a main storage device, an auxiliary storage device, and a communication unit. A copy of the rule DB 32 is stored in the auxiliary storage device of the conversion server 18. An illustration of the internal configuration of the conversion server 18 is omitted.

  FIG. 17 is a flowchart showing a flow of processing of the program according to the second embodiment. The processing flow of this embodiment will be described with reference to FIG.

  The CPU of the second client 25 obtains input pieces 28 that are sequentially generated (step S601). The CPU of the second client 25 transmits the acquired input card 28 to the server 11 and the conversion server 18 via the network (step S602).

  When the server CPU 12 receives the input card 28, the server CPU 12 performs an interrupt process and stores the data of the input card 28 in the storage DB 31. The interrupt process when receiving the input piece 28 is not described in the flowchart.

  The server CPU 12 acquires a notification for instructing the start of the rule generation process (step S653). The notification is generated by a clock built in the server 11 at a predetermined time or every predetermined time interval. The notification may be, for example, a signal received via a network or an interrupt signal.

  The server CPU 12 activates a rule creation subroutine (step S654). The rule creation subroutine is a subroutine for creating a rule to be recorded in the rule DB 32 based on the input individual sheets 28 accumulated in the accumulation DB 31. The rule creation subroutine is the same as the subroutine described with reference to FIG.

  The server CPU 12 updates the rule DB 32 with the rules created in step S654. The server CPU 12 transmits the rule DB 32 to the conversion server 18 (step S655). The server CPU 12 determines whether or not to end the process (step S656). The case where the process is ended is a case where an input for ending the process for generating the processing rule is received via the network, for example.

  If it is determined not to end the process (NO in step S656), the server CPU 12 returns to step S653. If it is determined that the process is to be ended (YES in step S656), the server CPU 12 ends the process.

  The CPU of the conversion server 18 receives the input card 28 (step S641). The CPU of the conversion server 18 starts a conversion processing subroutine (step S642). The conversion processing subroutine is a subroutine for converting the input vote 28 into the output vote 29 based on the rules recorded in the rule DB 32. The subroutine for the conversion process is the same subroutine as the subroutine described with reference to FIG.

  The CPU of the conversion server 18 transmits the output vote 29 to the network (step S643). Thereafter, the CPU of the conversion server 18 enters a standby state.

  The CPU of the conversion server 18 receives the rule DB 32 transmitted in step S655 (step S644). The CPU of the conversion server 18 updates the copy of the rule DB 32 stored in the auxiliary storage device (step S645). Thereafter, the CPU of the conversion server 18 enters a standby state.

  According to the present embodiment, even when the frequency of occurrence of the input documents 28 is high, the information processing system that updates the rules used for processing while sequentially processing the input documents 28 and outputting the output documents 29 10 can be provided.

  The rule DB 32 may be stored in a storage device (not shown) connected to the network. In this case, the conversion server 18 can perform the conversion process in step S642 using the rule DB 32 stored in a storage device (not shown).

[Embodiment 3]
The present embodiment relates to an information processing system 10 that converts an input slip 28 that records purchase results by Internet shopping into an output slip 29 that records recommended products. Note that description of portions common to the first embodiment is omitted.

  In the present embodiment, the first client 21 is the same as the second client 25. In other words, the output client 29 output by the server CPU 12 is received by the second client 25 that has transmitted the original input player 28 via the network.

  FIG. 18 is an explanatory diagram for explaining the conversion result of the third embodiment. FIG. 18 shows an input vote 28 describing products purchased by a customer through Internet shopping, and an output vote 29 describing recommended products. One line of FIG. 18 shows one internet shopping transaction.

  FIG. 19 is an explanatory diagram illustrating an example of the rule DB 32 according to the third embodiment. The rule DB 32 is No. It has a field, a condition field, and a recommended product field. The rule DB 32 has one record for one rule used for conversion.

  In the present embodiment, the second client 25 creates an input slip 28 describing a product purchased by a customer through Internet shopping and transmits it to the network. The server CPU 12 converts the input vote 28 into an output vote 29 based on the rule DB 32 and transmits it to the second client 25 via the network. The server CPU 12 accumulates the input pieces 28 in the accumulation DB 31. The second client 25 displays the recommended product for the customer on the Internet shopping screen based on the output individual sheet 29.

  The conversion process will be described more specifically. According to the first input piece 28 shown in FIG. 18, the customer has purchased a learning desk and a chair, but has not purchased a school bag. The server CPU 12 determines that the school bag is a recommended product based on the rule DB 32. The server CPU 12 outputs an output card 29 describing the school bag.

  According to the second input piece 28 shown in FIG. 18, the customer has purchased coffee beans and a mug. The server CPU 12 determines that the cookie is a recommended product based on the rule DB 32. The server CPU 12 outputs an output card 29 describing the cookie.

  The server CPU 12 creates and updates the rule DB 32 based on the statistical analysis results of the input individual records 28 stored in the storage DB 31 and information on seasons, trends, and the like.

  According to the present embodiment, it is possible to provide an information processing system 10 that promptly outputs recommended products according to products purchased by a customer.

  The input card 28 includes information on the past purchase history of the same customer, and the rule DB 32 may use the past purchase history for determining recommended products. In this way, it is possible to provide the information processing system 10 that recommends a product that can be expected to be purchased regularly, such as consumables, to the customer in a timely manner.

  In addition, it is possible to provide an arbitrary information processing system 10 that updates the rules used for the conversion in parallel while sequentially converting the input pieces 28 into the output pieces 29.

[Embodiment 4]
FIG. 20 is a functional block diagram illustrating the operation of the information processing apparatus according to the fourth embodiment. The server 11, which is an example of the information processing apparatus according to the present embodiment, operates as follows based on control by the server CPU 12.

  The information processing apparatus 11 includes an acquisition unit 51 that acquires an input piece 28, a conversion unit 52 that converts the input piece 28 acquired by the acquisition unit 51 based on a rule, and an input piece acquired by the acquisition unit 51. 28, a generation unit 54 that generates a new rule based on a plurality of input pieces 28 stored by the storage unit 53, and a new unit that generates a rule used by the conversion unit 52. And an updating unit 55 for updating to a proper rule.

[Embodiment 5]
The fifth embodiment relates to a mode for realizing the information processing apparatus of the present embodiment by operating a general-purpose computer and a program 47 in combination. FIG. 21 is an explanatory diagram illustrating a configuration of the information processing system 10 according to the fifth embodiment. The configuration of this embodiment will be described with reference to FIG. Note that description of portions common to the first embodiment is omitted.

  The information processing system 10 according to the present embodiment includes a server computer 45, a first client 21, and a second client 25. The server computer 45, the first client 21 and the second client 25 are connected via a network.

  The server computer 45 includes a server CPU 12, a main storage device 13, an auxiliary storage device 14, a communication unit 15, a reading unit 17, and a bus. The server computer 45 is an information device such as a general-purpose personal computer or a large computer. Further, the computer 45 of this embodiment may be a virtual machine that operates on a large computer.

  The program 47 is recorded on a portable recording medium 48. The server CPU 12 reads the program 47 via the reading unit 17 and stores it in the auxiliary storage device 14. The server CPU 12 may read the program 47 stored in the semiconductor memory 49 such as a flash memory mounted in the server computer 45. Further, the server CPU 12 may download the program 47 from another server computer (not shown) connected via the communication unit 15 and a network (not shown) and store the program 47 in the auxiliary storage device 14.

  The program 47 is installed as a control program for the server computer 45, loaded into the main storage device 13, and executed. Thereby, the server computer 45 functions as the server 11 described above.

The technical features (components) described in each embodiment can be combined with each other, and new technical features can be formed by combining them.
The embodiments disclosed herein are illustrative in all respects and should not be considered as restrictive. The scope of the present invention is defined not by the above-described meaning but by the scope of the claims, and is intended to include all modifications within the meaning and scope equivalent to the scope of the claims.

  With respect to the embodiments including the first to fifth embodiments, the following additional notes are disclosed.

(Appendix 1)
An acquisition unit for acquiring input pieces,
A conversion unit that converts the input pieces acquired by the acquisition unit based on a rule;
An accumulation unit for accumulating the input pieces acquired by the acquisition unit;
A generation unit that generates a new rule based on the plurality of input pieces accumulated by the accumulation unit;
An information processing apparatus comprising: an update unit that updates a rule used by the conversion unit to a new rule generated by the generation unit.
(Appendix 2)
The information processing apparatus according to attachment 1, wherein the conversion unit sequentially converts the acquired input pieces.
(Appendix 3)
The information processing apparatus according to appendix 1 or appendix 2, wherein the conversion unit operates with priority over the generation unit.
(Appendix 4)
The information processing apparatus according to any one of Supplementary Note 1 to Supplementary Note 3, wherein the conversion unit operates with priority over the update unit.
(Appendix 5)
When the generation unit determines that input pieces that are not used for rule generation are stored in the storage unit, the generation unit starts generation of a new rule. The information processing apparatus described.
(Appendix 6)
The information processing apparatus according to any one of appendix 1 to appendix 5, wherein the rule is a rule for anonymizing the input card.
(Appendix 7)
The information processing apparatus according to any one of supplementary notes 1 to 6, wherein the storage unit does not accumulate the input pieces when the input pieces and the conversion result obtained by converting the input pieces by the conversion unit are the same.
(Appendix 8)
Get the input piece,
Convert the obtained input piece based on the rules,
Accumulate the obtained input pieces,
A new rule is generated based on the accumulated plural input pieces,
An information processing method for causing a computer to execute a process for updating a rule for converting the input piece to a new rule generated.
(Appendix 9)
Get the input piece,
Convert the obtained input piece based on the rules,
Accumulate the obtained input pieces,
A new rule is generated based on the accumulated plural input pieces,
A program for causing a computer to execute a process of updating a rule for converting the input individual piece to a new rule generated.

10 Information Processing System 11 Server (Information Processing Device)
12 Server CPU
13 Main Storage Device 14 Auxiliary Storage Device 15 Communication Unit 17 Reading Unit 18 Conversion Server 21 First Client 25 Second Client 28 Input Item 29 Output Item 31 Storage DB
32 Rule DB
45 server computer 47 program 48 portable storage medium 49 semiconductor memory 51 acquisition unit 52 conversion unit 53 storage unit 54 generation unit 55 update unit

Claims (9)

An acquisition unit for acquiring input pieces,
A conversion unit that converts the input pieces acquired by the acquisition unit based on a rule;
An accumulation unit for accumulating the input pieces acquired by the acquisition unit;
A generation unit that generates a new rule based on the plurality of input pieces accumulated by the accumulation unit;
An information processing apparatus comprising: an update unit that updates a rule used by the conversion unit to a new rule generated by the generation unit.   The information processing apparatus according to claim 1, wherein the conversion unit sequentially converts the acquired input pieces.   The information processing apparatus according to claim 1, wherein the conversion unit operates preferentially over the generation unit.   The information processing apparatus according to claim 1, wherein the conversion unit operates preferentially over the update unit.   5. The generation unit according to claim 1, wherein the generation unit starts generation of a new rule when it is determined that input pieces that are not used for generation of a rule are stored in the storage unit. Information processing apparatus described in one.   The information processing apparatus according to claim 1, wherein the rule is a rule for anonymizing the input piece.   7. The information processing according to claim 1, wherein when the input piece and the conversion result obtained by converting the input piece by the conversion unit are the same, the storage unit does not accumulate the input piece. apparatus. Get the input piece,
Convert the obtained input piece based on the rules,
Accumulate the obtained input pieces,
A new rule is generated based on the accumulated plural input pieces,
An information processing method for causing a computer to execute a process for updating a rule for converting the input piece to a new rule generated. Get the input piece,
Convert the obtained input piece based on the rules,
Accumulate the obtained input pieces,
A new rule is generated based on the accumulated plural input pieces,
A program for causing a computer to execute a process of updating a rule for converting the input individual piece to a new rule generated.

Images