A method and apparatus for DeMura table data compression and decompression based on RNN neural network.

Abstract

This invention discloses a method and apparatus for compressing and decompressing DeMura table data based on an RNN neural network. The method includes the following steps: Step S1, randomly collecting DeMura table samples from several OLED displays to construct a DeMura table training set; Step S2, establishing an RNN neural network to automatically learn the inherent correlations of the DeMura table, and using the sample data from the DeMura table training set to train the model, obtaining a trained DeMura table compression and decompression model; Step S3, applying the DeMura table compression and decompression model obtained in Step S2 to compress and decompress any DeMura table.

Description

Technical Field

[0001] This invention relates to the field of image processing technology, and in particular to a method and apparatus for compressing and decompressing DeMura table data based on an RNN neural network. Background Technology

[0002] OLED (Organic Light-Emitting Diode), as a current-driven light-emitting device, is increasingly being used in high-performance displays. Due to its self-emissive nature, OLED offers many advantages over LCDs, including higher contrast, ultra-thinness, and flexibility. However, brightness uniformity and image retention remain two major challenges. Solving these problems requires not only improvements in manufacturing processes but also compensation techniques.

[0003] During the manufacturing process of OLED screens, the distribution of luminous intensity exhibits a Mura (uniformity) phenomenon, which requires Demura (mura elimination) compensation and repair to achieve a more uniform brightness distribution. A complete Demura technology flowchart can be found here. Figure 1 As shown, the specific steps are as follows:

[0004] Step 1. Turn on the screen and display several images (usually grayscale or RGB).

[0005] Step 2. Use a high-resolution and high-precision CCD camera (29M or higher) to capture the above images.

[0006] Step 3. After the captured data is transferred to the computer, the CCD resolution-level data is converted into sub-pixel data, and analysis processes such as alignment and correction are performed to generate mura image data.

[0007] Step 4. Analyze the mura image data and generate a Demura data table.

[0008] Step 5. Compress the Demura data table to generate the Demura data table bitstream.

[0009] Step 6. Burn the Demura datasheet stream into the FlashROM of the OLED screen module.

[0010] Step 7. Decompress the Demura data table stream.

[0011] Step 8. Perform image compensation according to the Demura data table to complete the Demura process.

[0012] As can be seen, the Demura restoration process generates a Demura data table, which is often quite large and requires a large-capacity OLED FLASH to store. However, large-capacity OLED FLASH is relatively expensive. The mainstream display resolution is 2560×1440, and high-end screens have resolutions as high as 4096×2160. For example, the single-pixel compensation table in the Demura data table is 32-bit, and the single-pixel compensation table of high-end OLED screens can even reach 64-bit or higher. Therefore, the size of the Demura data table for all pixels of the entire screen is 4096×2160*32bit>=33.75M, which requires a large amount of Flash storage space. Therefore, it is necessary to compress the Demura data to save costs and facilitate processing.

[0013] In actual OLED production lines, the adjacent pixels in the mura image data of each OLED display exhibit strong randomness. Therefore, the adjacent pixels in the Demura data table generated from the mura image data also exhibit strong randomness. Traditional compression and decompression methods struggle to extract the correlations between pixels in this type of Demura data table. Furthermore, the feature extraction process is complex and requires significant expert resources, resulting in low compression efficiency for Demura data tables, typically around a 10x compression ratio, ultimately leading to limited cost savings. Summary of the Invention

[0014] To overcome the shortcomings of the existing technology, the present invention aims to provide a DeMura table data compression and decompression method and apparatus based on RNN neural network. By utilizing RNN neural network to automatically learn the inherent correlation of DeMura data table, the traditional method requires a large amount of expert human resources to manually screen correlation features, which greatly simplifies the development and optimization process of the entire compression and decompression algorithm, shortens the development time and cost of OLED screen products, and improves the compression ratio.

[0015] To achieve the above objectives, this invention proposes a DeMura table data compression and decompression method based on an RNN neural network, comprising the following steps:

[0016] Step S1: Randomly collect several Demura data table samples from OLED displays to construct a Demura data table training set;

[0017] Step S2: Establish an RNN neural network to automatically learn the inherent correlation of the Demura data table. Use the sample data of the Demura data table training set to train the model and obtain a trained Demura data table compression and decompression model.

[0018] The Demura data table compression and decompression model obtained in step S2 is used to compress and decompress any Demura data table.

[0019] Preferably, in step S1, a certain number of mura image samples of OLED displays are randomly collected from the current OLED production line, and Demura data table samples are calculated using the Demura algorithm, thereby constructing the Demura data table training set.

[0020] Preferably, step S2 further includes:

[0021] Step S200: Randomly initialize the initial training set sample index;

[0022] Step S201: Read a Demura data table sample in order according to the randomly shuffled sample index;

[0023] Step S202: The read Demura data table sample is compressed using a feature encoder and a binarization encoder to generate a binarized encoded bitstream of the Demura data table.

[0024] Step S203: Decompress the binarized encoded bitstream of the Demura data table using a decoder;

[0025] Step S204: Calculate the residual based on the decompression result and the sample input data obtained in step S201;

[0026] Step S205: After a preset number of iterations, calculate the total error of the compression and decompression process within that number of iterations;

[0027] Step S206: After the training set has been sampled, calculate the average error of the current training and determine whether to continue training or end the training process based on the average error of the current training.

[0028] Preferably, in step S201, the read Demura data table sample is divided into blocks.

[0029] Preferably, in step S202, the feature encoder processes the Demura data table sample data through one CNN convolution E-Conv and three RNN convolutions. The kernel size of each convolution is 3×3 and the stride is 2×2. The RNN convolution uses the classic LSTM model.

[0030] Preferably, the binarization encoder processes the output of the feature encoder through a CNN convolution B-Conv with a kernel size of 1×1 and a stride of 1×1.

[0031] Preferably, in step S206, if the sample counter i < M, where M is the total number of samples in the training set, then i = i + 1, and jump to step S201 to continue reading the next sample for compression and decompression training; if the sample counter i ≥ M, then use the total error obtained in step S205 to calculate the average error of the current training.

[0032] Preferably, if the average error Err ≥ δ, where δ represents a preset threshold, then proceed to step S200 to continue the model training process; if the average error Err < δ, then save the trained model weight parameters to files respectively, end the training process, and obtain the trained Demura data table compression and decompression model.

[0033] Preferably, in step S3, the compression application includes the following steps:

[0034] Step S300: Read any Demura data table and perform block partitioning;

[0035] Step S301: The Demura data table samples after block division in step S300 are compressed using a feature encoder and a binarization encoder to generate a binarized encoded bitstream of the Demura data table.

[0036] Step S302: Decompress the binarized encoded bitstream of the Demura data table obtained in step S201 using a decoder;

[0037] Step S303: Calculate the residual based on the decompression result and the sample input data obtained in step S301;

[0038] Step S304: After a preset number of iterations, save the binarized encoded bitstream of the Demura data table generated in step S301 to the FlashRom of the OLED screen module.

[0039] To achieve the above objectives, the present invention also provides a DeMura table data compression and decompression device based on an RNN neural network, comprising:

[0040] The training set construction unit is used to randomly collect Demura data table samples from several OLED displays and construct the Demura data table training set.

[0041] The model building and training unit is used to build an RNN neural network to automatically learn the inherent correlation of the Demura data table. The model is trained using sample data from the Demura data table training set to obtain a trained Demura data table compression and decompression model.

[0042] The compression and decompression application unit is used to apply the compression and decompression model of the Demura data table obtained by the model building and training unit to any Demura data table.

[0043] Compared with existing technologies, the present invention provides a DeMura table data compression and decompression method and apparatus based on RNN neural network. By utilizing RNN neural network to automatically learn the inherent correlation of DeMura data table, the traditional method eliminates the need for a large amount of expert human resources to manually screen correlation features, greatly simplifying the development and optimization process of the entire compression and decompression algorithm, shortening the development time and cost of OLED screen products, and improving the compression ratio. Attached Figure Description

[0044] Figure 1 A flowchart of the existing Demura technology;

[0045] Figure 2 This is a flowchart illustrating the steps of a DeMura table data compression and decompression method based on an RNN neural network according to the present invention.

[0046] Figure 3 This is a detailed flowchart of step S2 in a specific embodiment of the present invention;

[0047] Figure 4 This is a flowchart illustrating the compression calculation process of the Demura data table in a specific embodiment of the present invention.

[0048] Figure 5 This is a flowchart illustrating the decompression calculation process of the Demura data table in a specific embodiment of the present invention.

[0049] Figure 6 This is a system architecture diagram of a DeMura table data compression and decompression device based on an RNN neural network according to the present invention;

[0050] Figure 7 This is a detailed structural diagram of the model building and training unit in a specific embodiment of the present invention.

[0051] Figure 8 This is a flowchart of the DeMura table data compression and decompression method according to an embodiment of the present invention;

[0052] Figure 9This is a flowchart illustrating the training process of the compression and decompression model for the Demura data table based on an RNN neural network in this embodiment of the invention.

[0053] Figure 10 This is a schematic diagram of the LSTM neural network in an embodiment of the present invention;

[0054] Figure 11 This is a flowchart illustrating the Demura data table compression application in an embodiment of the present invention.

[0055] Figure 12 This is a flowchart illustrating the Demura data table decompression application process in an embodiment of the present invention. Detailed Implementation

[0056] The following describes the embodiments of the present invention through specific examples and in conjunction with the accompanying drawings. Those skilled in the art can easily understand other advantages and effects of the present invention from the content disclosed in this specification. The present invention can also be implemented or applied through other different specific examples, and various details in this specification can also be modified and changed based on different viewpoints and applications without departing from the spirit of the present invention.

[0057] Figure 2 This is a flowchart illustrating the steps of a DeMura table data compression and decompression method based on an RNN neural network according to the present invention. Figure 2 As shown, the present invention provides a DeMura table data compression and decompression method based on an RNN neural network, comprising the following steps:

[0058] Step S1: Randomly collect mura data samples from several OLED displays to construct a Demura data table training set.

[0059] In this invention, a certain number of mura image samples from OLED displays are randomly collected from the current OLED production line (the collection of mura data samples is described in steps 1 to 3 of the background technology, and will not be repeated here). The Demura data table samples are then calculated using the Demura algorithm to construct a Demura data table training set. In a specific embodiment of this invention, the Demura data table samples used have a resolution of 2560×1440 (not limited to other resolutions), 4 channels (not limited to other channel numbers), and a data bit width of 8 bits (not limited to other data bit widths). The total number of samples in the constructed training set is denoted as M. It should be noted that this invention does not concern itself with how the Demura algorithm calculates the Demura data table samples, but only with the compression and decompression processing of the Demura data table.

[0060] Step S2: Establish an RNN neural network to automatically learn the inherent correlations of the Demura data table. Use the sample data of the Demura data table training set to train the model and obtain a trained Demura data table compression and decompression model.

[0061] Specifically, such as Figure 3 As shown, step S2 further includes:

[0062] Step S200: Randomly initialize the training set sample index.

[0063] Since the stochastic gradient descent method relies heavily on the randomness of the training set samples, if the training set samples are not shuffled, outliers may be concentrated in a certain area, interfering with the algorithm's convergence and fitting. Therefore, in this invention, the order of the M Demura data table samples in the training set is randomly shuffled. This better reflects the true distribution of the Demura data table, prevents overfitting during model training, and facilitates model convergence.

[0064] Step S201: Read a Demura data table sample in order according to the randomly shuffled sample index, denoted as X. i The superscript indicates the i-th Demura data table sample.

[0065] To reduce inter-block dependencies, minimize buffer space during decompression, and facilitate hardware implementation, the read Demura data table sample needs to be divided into blocks. The specific process is as follows: The 2560×1440×4 sample is divided into blocks of 16×16×4 size (not limited to 16×16 block size). All 16×16×4 blocks are then stacked into N×16×16×4 blocks, where N = (2560+16-1) / 16×(1440+16-1) / 16, and N is called the Batchsize. Finally, the data is converted to a float data type, denoted as x. i .

[0066] Step S202: The read Demura data table sample is iteratively compressed using a feature encoder and a binarization encoder to generate a binarized encoded bitstream of the Demura data table (in this example, a 1×1×256-bit bitstream is generated).

[0067] In a specific embodiment of the present invention, such as Figure 4As shown, the detailed calculation process of the feature encoder includes: processing the block-based Demura data table sample data (16×16×4 in this embodiment) through one CNN convolution E-Conv and three RNN convolutions (E-RNN#1, E-RNN#2 and E-RNN#3 respectively) (the output of this example is 3×3×512 float type feature data). The kernel size of each convolution is 3×3 and the stride is 2×2. The RNN convolutions (E-RNN#1, E-RNN#2 and E-RNN#3) use the classic LSTM model (not limited to the LSTM model, but can also be a variant of the LSTM model, such as the Associative LSTM model, GRU model and other RNN models). This invention is not limited to this.

[0068] The binary encoder computation process consists of only one CNN convolution B-Conv with a kernel size of 1×1, a stride of 1×1, and 256 output channels (not limited to 256; other channel numbers are also possible, and can be flexibly adjusted according to the actual application scenario. For example, when the OLED production line has high quality and the inherent correlation of the Demura data table is stronger, the number of channels can be changed to 128, 64, or even 32 or 16, resulting in a higher compression ratio and a more obvious cost-saving advantage of FlashROM).

[0069] The initialization of the compression iterative process can be represented by the following formula:

[0070]

[0071] in x represents i The initial reconstruction result, r0 represents the initial original value x. i With reconstruction results The residual is represented by the subscript 0, which indicates the compression / decompression iteration counter, i.e., the 0th iteration (or the initial residual).

[0072] The single-step iterative process of compression can be represented by the following formula:

[0073] b t =B(E) t (r t-1 ))

[0074] The subscript symbol indicates the current t-th iteration, and the maximum number of iterations is 16 (not limited to 16 iterations). t-1 E represents the residual from the previous iteration. tLet B represent the state of the feature encoder in the t-th iteration, and let B represent the binary encoder. t This represents the binary encoded bit stream of the t-th iteration.

[0075] Step S203: The binarized encoded bitstream of the Demura data table is iteratively decompressed using a decoder.

[0076] like Figure 5 As shown, the detailed computation process of the decoder includes: one CNN convolution D-Conv#1 and D-Conv#2, with a kernel size of 1×1 and a stride of 1×1; and four RNN convolutions (D-RNN#1, D-RNN#2, D-RNN#3, and D-RNN#4), with kernel sizes of 2×2, 3×3, 3×3, and 3×3, respectively, and a stride of 1×1 for each. The RNN convolutions (D-RNN#1, D-RNN#2, D-RNN#3, and D-RNN#4) use the classic LSTM model (not limited to LSTM; it can be a variant of LSTM, such as the Associative LSTM model, GRU model, etc.).

[0077] The single-step iterative process of decompression can be represented by the following formula:

[0078]

[0079] Where the subscript symbol indicates the current t-th iteration, b t D represents the binary encoded bit stream of the t-th iteration. t This represents the decoder state in the t-th iteration. This represents the reconstruction residual result of the t-th iteration.

[0080] Step S204: Calculate the residual based on the decompression result and the sample input data obtained in step S201.

[0081] Specifically, the single-step iterative process of residual calculation can be represented by the following formula:

[0082]

[0083] Where the subscript symbol indicates the current t-th iteration, x i This represents the input data for the i-th sample. Let r represent the reconstruction residual result of the t-th iteration. t Let r represent the residual of the t-th iteration. t Modulus length ||r t The smaller the value of ||, the higher the quality of the final reconstruction result.

[0084] Step S205: After a preset number of iterations, calculate the total error of the compression and decompression process within that number of iterations.

[0085] In a specific embodiment of the present invention, error statistics are expressed by the following formula:

[0086]

[0087] The subscript symbol indicates the current t-th iteration, r t Let β represent the residual of the t-th iteration. t Err represents the residual statistical adjustment weight in the t-th iteration. i Let x represent the i-th sample. i The total error in the compression and decompression process.

[0088] Step S206: After the training set has been sampled, calculate the average error of the current training and determine whether to continue training or end the training process based on the average error of the current training.

[0089] Specifically, if the sample counter i < M, then i = i + 1, and jump to step S201 to continue reading the next sample for compression and decompression training; if the sample counter i ≥ M, then calculate the average error of the current training, which can be done using the following formula:

[0090] The average error is expressed by the following formula:

[0091]

[0092] Among them, Err i Let x represent the i-th sample. i The total error of the compression and decompression process, M represents the total number of samples in the training set, and Err represents the average error of the current training.

[0093] If the average error Err ≥ δ (where δ represents a preset threshold), proceed to step S200 to continue the model training process; if the average error Err < δ, save the trained model weight parameters to files respectively for subsequent model application, end the training process, and obtain the trained Demura data table compression and decompression model.

[0094] Step S3: Apply the Demura data table compression and decompression model obtained in step S2 to compress and decompress any Demura data table.

[0095] Specifically, in step S3, the process of compressing the application is as follows:

[0096] Step S300: Read any Demura data table and perform block partitioning.

[0097] In this invention, during the compression application stage, only one Demura data table needs to be read, denoted as X. To reduce the correlation between blocks, reduce the buffer space in the decompression process, and facilitate hardware implementation, the Demura data table sample needs to be divided into blocks. The specific process is described in step S201 of step S2: the sample 2560×1440×4 is divided into blocks of 16×16×4 size, then stacked to obtain N×16×16×4 block data, which is finally converted into float data type, denoted as x.

[0098] Step S301: The Demura data table samples after block division in step S300 are compressed using a feature encoder and a binarization encoder to generate a binarized encoded bitstream of the Demura data table. Since the specific compression steps are as described in step S202, they will not be repeated here.

[0099] Step S302: The binarized encoded bitstream of the Demura data table obtained in step S201 is decompressed using a decoder. Since the specific decompression steps are as described in step S203, they will not be repeated here.

[0100] Step S303: Calculate the residual based on the decompression result and the sample input data obtained in step S201. The specific process is as described in step S204, and will not be elaborated here. Based on the residual, an RNN (Recurrent Neural Network) can be used to continuously iterate (16 iterations) to compress the residual. The purpose of this process is to minimize the residual as much as possible.

[0101] Step S304: After a preset number of iterations, save the binarized encoded bitstream of the Demura data table generated in step S301, which is the final compressed bitstream data. Specifically, after a preset number of iterations, save the binarized encoded bitstream of the Demura data table generated in step S301 to the FlashROM of the OLED screen module.

[0102] The process of decompressing the application is as follows:

[0103] Step S400: Read the compressed bitstream (1×1×256bit) of the Demura data table in the FlashROM of the OLED screen module block by block, denoted as b. t , where t = 1.

[0104] Step S401: The obtained Demura data table compressed bitstream is decompressed using a decoder. The decompression process is the same as in step S203, and will not be described in detail here.

[0105] The single-step iterative process of decompression can be represented by the following formula:

[0106]

[0107] Where the subscript symbol indicates the current t-th iteration, b t D represents the binary encoded bit stream of the t-th iteration. t This represents the decoder state in the t-th iteration. This represents the reconstruction residual result of the t-th iteration.

[0108] The single-step iterative process of residual accumulation can be represented by the following formula:

[0109]

[0110] The subscript symbol indicates the current t-th iteration. Let x represent the reconstruction residual result of the t-th iteration. t This represents the cumulative reconstruction result of the t-th iteration. It should be noted that in this invention, the compression encoding stage is residual calculation (subtraction calculation), while the decompression stage is residual accumulation (addition calculation, i.e., the inverse process of residual calculation), used to reconstruct an approximate original data.

[0111] Step S402: After several iterations, the final reconstruction result is obtained, and its x... 16 It is sent to the Demura compensation module for Demura compensation calculation.

[0112] If the sample counter t ≤ 16, then t = t + 1, and proceed to step S401; otherwise, the calculation process terminates, and the final reconstructed Demura data table x is generated. 16 It is sent to the Demura compensation module for Demura compensation calculation.

[0113] Figure 6 This is a system architecture diagram of a DeMura table data compression and decompression device based on an RNN neural network according to the present invention. Figure 6 As shown, the present invention provides a DeMura table data compression and decompression device based on an RNN neural network, comprising:

[0114] Training set construction unit 60 is used to randomly collect Demura data table samples from several OLED displays to construct a Demura data table training set.

[0115] In this invention, a certain number of mura image samples from OLED displays are randomly collected from the current OLED production line, and Demura data table samples are calculated using the Demura algorithm to construct a Demura data table training set. In a specific embodiment of this invention, the Demura data table samples used have a resolution of 2560×1440 (not limited to other resolutions), 4 channels (not limited to other channel numbers), and a data bit width of 8 bits (not limited to other data bit widths). The total number of samples in the constructed training set is denoted as M.

[0116] The model building and training unit 61 builds an RNN neural network to automatically learn the inherent correlation of the Demura data table. It uses the sample data of the Demura data table training set to train the model and obtain a trained Demura data table compression and decompression model.

[0117] Specifically, such as Figure 7 As shown, the model building and training unit 61 further includes:

[0118] The random initialization module 610 is used to randomly initialize the training set sample index.

[0119] Since the stochastic gradient descent method relies heavily on the randomness of the training set samples, if the training set samples are not shuffled, outliers may be concentrated in a certain area, interfering with the algorithm's convergence and fitting. Therefore, in this invention, the order of the M Demura data table samples in the training set is randomly shuffled. This better reflects the true distribution of the Demura data table, prevents overfitting during model training, and facilitates model convergence.

[0120] The sample acquisition and processing module 611 is used to read a Demura data table sample in sequence according to the randomly shuffled sample index, denoted as X. i The superscript indicates the i-th Demura data table sample.

[0121] To reduce inter-block dependencies, minimize buffer space during decompression, and facilitate hardware implementation, the read Demura data table sample needs to be divided into blocks. The specific process is as follows: The 2560×1440×4 sample is divided into blocks of 16×16×4 size (not limited to 16×16 block size). All 16×16×4 blocks are then stacked into N×16×16×4 blocks, where N = (2560+16-1) / 16×(1440+16-1) / 16, and N is called the Batchsize. Finally, the data is converted to a float data type, denoted as x. i .

[0122] The compression processing module 612 is used to compress the read Demura data table samples using a feature encoder and a binarization encoder to generate a binarized encoded bitstream of the Demura data table.

[0123] In a specific embodiment of the present invention, such as Figure 4 As shown, the detailed calculation process of the feature encoder of the compression processing module 612 includes: processing the block-based Demura data table sample data (16×16×4 in this embodiment) through one CNN convolution E-Conv and three RNN convolutions (E-RNN#1, E-RNN#2 and E-RNN#3 respectively). The kernel size of each convolution is 3×3 and the stride is 2×2. The RNN convolutions (E-RNN#1, E-RNN#2 and E-RNN#3) adopt the classic LSTM model (not limited to the LSTM model, but can also be a variant of the LSTM model, such as the AssociativeLSTM model, the GRU model and other RNN models).

[0124] The binary encoder computation process consists of only one CNN convolution B-Conv with a kernel size of 1×1, a stride of 1×1, and 256 output channels (not limited to 256; other channel numbers are also possible, and can be flexibly adjusted according to the actual application scenario. For example, when the OLED production line has high quality and the inherent correlation of the Demura data table is stronger, the number of channels can be changed to 128, 64, or even 32 or 16, resulting in a higher compression ratio and a more obvious cost-saving advantage of FlashROM).

[0125] The initialization of the compression iterative process can be represented by the following formula:

[0126]

[0127] in x represents i The initial reconstruction result, r0 represents the initial original value x. i With reconstruction results The residual is represented by the subscript 0, which indicates the compression / decompression iteration counter, i.e., the 0th iteration (or the initial residual).

[0128] The single-step iterative process of compression can be represented by the following formula:

[0129] b t =B(E) t (r t-1 ))

[0130] The subscript symbol indicates the current t-th iteration, and the maximum number of iterations is 16 (not limited to 16 iterations). t-1 E represents the residual from the previous iteration. t Let B represent the state of the feature encoder in the t-th iteration, and let B represent the binary encoder. t This represents the binary encoded bit stream of the t-th iteration.

[0131] The decompression processing module 613 is used to decompress the binarized encoded bitstream of the Demura data table using a decoder.

[0132] like Figure 5 As shown, the detailed calculation process of the decoder (Encoder) in the decompression processing module 613 includes: one CNN convolution D-Conv#1 and D-Conv#2 with a kernel size of 1×1 and a stride of 1×1; and four RNN convolutions (D-RNN#1, D-RNN#2, D-RNN#3, and D-RNN#4) with kernel sizes of 2×2, 3×3, 3×3, and 3×3, respectively, and a stride of 1×1 for each. The RNN convolutions (D-RNN#1, D-RNN#2, D-RNN#3, and D-RNN#4) use the classic LSTM model (not limited to LSTM, but can be variations of LSTM, such as Associative LSTM, GRU, etc.).

[0133] The single-step iterative process of decompression can be represented by the following formula:

[0134]

[0135] Where the subscript symbol indicates the current t-th iteration, b t D represents the binary encoded bit stream of the t-th iteration. t This represents the decoder state in the t-th iteration. This represents the reconstruction residual result of the t-th iteration.

[0136] The residual calculation module 614 is used to calculate the residual based on the decompression result and the sample input data obtained by the sample acquisition and processing module 611.

[0137] Specifically, the single-step iterative process of residual calculation can be represented by the following formula:

[0138]

[0139] Where the subscript symbol indicates the current t-th iteration, x i This represents the input data for the i-th sample. Let r represent the reconstruction residual result of the t-th iteration. t Let r represent the residual of the t-th iteration. t Modulus length ||r t The smaller the value of ||, the higher the quality of the final reconstruction result.

[0140] The error statistics module 615 is used to calculate the total error of the compression and decompression process within a preset number of iterations.

[0141] In a specific embodiment of the present invention, error statistics are expressed by the following formula:

[0142]

[0143] The subscript symbol indicates the current t-th iteration, r t Let β represent the residual of the t-th iteration. t Err represents the residual statistical adjustment weight in the t-th iteration. i Let x represent the i-th sample. i The total error in the compression and decompression process.

[0144] The training end judgment module 616 is used to calculate the average error of the current training after the training set has been sampled, and to determine whether to continue training or end the training process based on the average error of the current training.

[0145] Specifically, if the sample counter i < M, then i = i + 1, and the process returns to the sample acquisition and processing module 611 to continue reading the next sample for compression and decompression training; if the sample counter i ≥ M, then the average error of the current training is calculated using the following formula:

[0146] The average error is expressed by the following formula:

[0147]

[0148] Among them, Err i Let x represent the i-th sample. i The total error of the compression and decompression process, M represents the total number of samples in the training set, and Err represents the average error of the current training.

[0149] If the average error Err ≥ δ (where δ represents the preset threshold), then return to the random initialization module 610 and continue the model training process; if the average error Err < δ, then save the trained model weight parameters to files respectively for subsequent model application, end the training process, and obtain the trained Demura data table compression and decompression model.

[0150] The compression and decompression application unit 62 is used to compress and decompress any Demura data table using the Demura data table compression and decompression model obtained by the model building and training unit 61.

[0151] Specifically, the compression application process of the compression / decompression application unit 62 is as follows:

[0152] Read any Demura data table and divide it into blocks.

[0153] In this invention, during the compression application stage, only one Demura data table needs to be read, denoted as X. To reduce the correlation between blocks, reduce the buffer space in the decompression process, and facilitate hardware implementation, the Demura data table sample needs to be divided into blocks. The specific process is described in step S201 of step S2: the sample 2560×1440×4 is divided into blocks of 16×16×4 size, then stacked to obtain N×16×16×4 block data, which is finally converted into float data type, denoted as x.

[0154] The Demura data table samples after block partitioning are compressed using a feature encoder and a binarization encoder to generate a binarized encoded bitstream of the Demura data table.

[0155] The binarized encoded bitstream of the obtained Demura data table is decompressed using a decoder.

[0156] The residual is calculated based on the decompression results and the sample input data obtained after block partitioning.

[0157] After a preset number of iterations, the binary encoded bitstream of the compressed Demura data table is saved. Specifically, after a preset number of iterations, the binary encoded bitstream of the generated Demura data table is saved to the FlashROM of the OLED screen module.

[0158] The decompression process of the compression / decompression application unit 62 is as follows:

[0159] Read the compressed bitstream (1×1×256bit) of the Demura data table in the FlashROM of the OLED screen module in blocks, denoted as b. t , where t = 1.

[0160] The obtained Demura data table compressed stream is decompressed using a decoder.

[0161] The single-step iterative process of decompression can be represented by the following formula:

[0162]

[0163] Where the subscript symbol indicates the current t-th iteration, b t D represents the binary encoded bit stream of the t-th iteration. t This represents the decoder state in the t-th iteration. This represents the reconstruction residual result of the t-th iteration.

[0164] The single-step iterative process of residual accumulation can be represented by the following formula:

[0165]

[0166] The subscript symbol indicates the current t-th iteration. Let x represent the reconstruction residual result of the t-th iteration. t This represents the cumulative reconstruction in the t-th iteration.

[0167] After several iterations, the final reconstruction result is obtained, and its x... 16 It is sent to the Demura compensation module for Demura compensation calculation.

[0168] If the sample counter t ≤ 16, then t = t + 1, and the process jumps to the decompression step to continue decompression; otherwise, the calculation process terminates, and the final reconstructed Demura data table x is generated. 16 It is sent to the Demura compensation module for Demura compensation calculation.

[0169] Example

[0170] In this embodiment, as Figure 8 As shown, the DeMura table data compression and decompression process based on RNN neural network of this invention is as follows:

[0171] Step 1: Construct the Demura dataset training set

[0172] For the current OLED production line, a certain number of mura image samples of OLED displays are randomly collected. The Demura data table samples are calculated using the Demura algorithm to construct a Demura data table training set. In this invention example, the resolution of the Demura data table samples is 2560×1440 (not limited to other resolutions), the number of channels is 4 (not limited to other channel numbers), and the data bit width is 8 bits (not limited to other data bit widths). The total number of samples in the constructed training set is denoted as M.

[0173] Step 2: Training the Demura data table compression and decompression model based on RNN neural network

[0174] The main idea of ​​this invention is to automatically learn the inherent correlations in the Demura data table using an RNN neural network. This eliminates the need for the manual screening of correlation features, which requires significant expert resources and is a hallmark of traditional methods. It greatly simplifies the development and optimization of the entire compression and decompression algorithm, reduces the development time and cost of OLED screen products, and also improves the compression ratio. Figure 9 As shown, the specific steps are as follows:

[0175] Step 1: Randomly initialize the training set sample index

[0176] Since the stochastic gradient descent method relies heavily on the randomness of the training set samples, if the training set samples are not shuffled, outliers may be concentrated in a certain area, interfering with the algorithm's convergence and fitting. Randomly shuffling the order of the M Demura data table samples in the training set better reflects the true distribution of the Demura data table, preventing overfitting during model training and facilitating model convergence.

[0177] Step 2: Sampling

[0178] Based on the randomly shuffled sample index from Step 1, a Demura data table sample is read sequentially, denoted as X. i The superscript indicates the i-th Demura data table sample. To reduce the dependency between blocks, reduce the buffer space during decompression, and facilitate hardware implementation, the Demura data table sample needs to be divided into blocks. The specific process is as follows: Divide the sample 2560×1440×4 into blocks of size 16×16×4 (not limited to 16×16 block size), and then stack all the 16×16×4 blocks into blocks of shape N×16×16×4, where N = (2560+16-1) / 16×(1440+16-1) / 16, and N is called the batch size. Finally, convert it to float data type, denoted as x. i .

[0179] Step 3: Compression

[0180] The flowchart of the compression calculation is as follows Figure 4 As shown, compression mainly involves the computation process of a feature encoder and a binarizer.

[0181] Specifically, the detailed computation process of the feature encoder includes: one CNN convolution E-Conv and three RNN convolutions (E-RNN#1, E-RNN#2, and E-RNN#3), all with a kernel size of 3×3 and a stride of 2×2. The RNN convolutions (E-RNN#1, E-RNN#2, and E-RNN#3) employ the classic LSTM model (not limited to LSTM; it can be a variant of LSTM, such as the Associative LSTM model, GRU model, or other RNN models). The schematic diagram of the LSTM model is shown below. Figure 10 As shown, the LSTM model is a specific form of RNN (Recurrent Neural Network), and RNN is a general term for a series of neural networks that can process sequential data.

[0182] The binary encoder computation process consists of only one CNN convolution B-Conv with a kernel size of 1×1 and a stride of 1×1. The number of output channels is 256 (not limited to 256; it can be other channel numbers, which can be flexibly adjusted according to the actual application scenario. For example, when the OLED production line has high quality and the inherent correlation of the Demura data table is stronger, the number of channels can be changed to 128, 64, or even 32 or 16, resulting in a higher compression ratio and a more obvious cost-saving advantage of FlashROM).

[0183] The initialization of the iterative process can be expressed by the following formula:

[0184]

[0185] in x represents i The initial reconstruction result, r0 represents the initial original value x. i With reconstruction results The residual is represented by the subscript 0, which indicates the compression / decompression iteration counter, i.e., the 0th iteration (or the initial residual).

[0186] The single-step iterative process of compression can be represented by the following formula:

[0187] b t =B(E) t (r t-1 ))

[0188] The subscript symbol indicates the current t-th iteration, and the maximum number of iterations is 16 (not limited to 16 iterations). t-1 E represents the residual from the previous iteration. tLet B represent the state of the feature encoder in the t-th iteration, and let B represent the binary encoder. t This represents the binary encoded bit stream of the t-th iteration.

[0189] Step 4: Unzip

[0190] The decompression calculation flowchart is as follows: Figure 5 As shown, the detailed computation process of the decoder includes: one CNN convolution D-Conv#1 and D-Conv#2 with a kernel size of 1×1 and a stride of 1×1; and four RNN convolutions (D-RNN#1, D-RNN#2, D-RNN#3, and D-RNN#4) with kernel sizes of 2×2, 3×3, 3×3, and 3×3, respectively, and a stride of 1×1 for each. The RNN convolutions (D-RNN#1, D-RNN#2, D-RNN#3, and D-RNN#4) use the classic LSTM model (not limited to LSTM; it can be a variant of LSTM, such as the Associative LSTM model, GRU model, etc.).

[0191] The single-step iterative process of decompression can be represented by the following formula:

[0192]

[0193] Where the subscript symbol indicates the current t-th iteration, b t D represents the binary encoded bit stream of the t-th iteration. t This represents the decoder state in the t-th iteration. This represents the reconstruction residual result of the t-th iteration.

[0194] Step 5: Residual Calculation

[0195] The single-step iterative process of residual calculation can be represented by the following formula:

[0196]

[0197] Where the subscript symbol indicates the current t-th iteration, x i This represents the input data for the i-th sample. Let r represent the reconstruction residual result of the t-th iteration. t Let r represent the residual of the t-th iteration. t Modulus length ||r t The smaller the value of ||, the higher the quality of the final reconstruction result.

[0198] Step 6: Error Statistics

[0199] Error statistics are expressed by the following formula:

[0200]

[0201] The subscript symbol indicates the current t-th iteration, r t Let β represent the residual of the t-th iteration. t Err represents the residual statistical adjustment weight in the t-th iteration. i Let x represent the i-th sample. i The total error in the compression and decompression process.

[0202] Step 7: Determine if the training set has been fully utilized.

[0203] If the sample counter i < M, then i = i + 1, and jump to Step 2 to continue the compression and decompression process of the next sample; if the sample counter i ≥ M, jump to Step 8 to calculate.

[0204] Step 8: Determine if the average error is small enough.

[0205] The average error is expressed by the following formula:

[0206]

[0207] Among them Err i Let x represent the i-th sample. i The total error of the compression and decompression process, M represents the total number of samples in the training set, and Err represents the average error of the current training.

[0208] If the average error Err ≥ δ (where δ represents the preset threshold), proceed to Step 1 for calculation and continue the model training process; if the average error Err < δ, proceed to Step 9 for calculation.

[0209] Step 9: Save the model

[0210] Save the trained model weight parameters to separate files for later model applications.

[0211] Step 3, Demura Data Table Compression Application

[0212] The main idea of ​​this step is to use the model trained in step 2 for compression applications. Specific implementation methods are as follows: Figure 11 The calculation steps are described one by one. Specifically:

[0213] Step 1: Divide into blocks

[0214] During the compression application phase, only one Demura data table needs to be read, denoted as X. To reduce the dependency between blocks, reduce the buffer space in the decompression process, and facilitate hardware implementation, the Demura data table sample needs to be divided into blocks. The specific process is as follows: the sample 2560×1440×4 is divided into blocks of 16×16×4 size, then stacked to obtain N×16×16×4 block data, which is finally converted into float data type, denoted as x.

[0215] Step 2: Compression

[0216] For detailed steps, please refer to the calculation process in Step 3 of Step 2.

[0217] Step 3: Unzip

[0218] For detailed steps, please refer to the calculation process in Step 4 of Step 2.

[0219] Step 4: Residual Calculation

[0220] For detailed steps, please refer to Step 5 of Step 2.

[0221] Step 5: Save the bitstream

[0222] The binary encoded bitstream b generated in Step 3 t The data is saved and streamed into the FlashROM of the OLED screen module, where the index t = 16. Based on the block size, the original input data bits are 16×16×4×8 bits, and the compressed bitstream size is 1×1×256 bits, achieving a compression ratio of 32 times, which is far more efficient than traditional compression methods.

[0223] Step 4, Demura data table decompression application

[0224] The main idea of ​​this step is to use the model trained in step 2 for decompression applications. Specific implementation methods are as follows: Figure 12 The calculation steps are described one by one. Specifically:

[0225] Step 1: Read the bitstream

[0226] During the decompression application phase, it is only necessary to read the compressed bitstream of the Demura data table in the FlashROM of the OLED screen module (1×1×256bit) block by block, denoted as b. t , where t = 1.

[0227] Step 2: Unzip

[0228] For detailed steps, please refer to the calculation process in Step 4 of Step 2.

[0229] The single-step iterative process of decompression can be represented by the following formula:

[0230]

[0231] Where the subscript symbol indicates the current t-th iteration, b t D represents the binary encoded bit stream of the t-th iteration. t This represents the decoder state in the t-th iteration. This represents the reconstruction residual result of the t-th iteration.

[0232] Step 3: Reconstruct the cumulative total

[0233] The single-step iterative process of residual accumulation can be represented by the following formula:

[0234]

[0235] The subscript symbol indicates the current t-th iteration. Let x represent the reconstruction residual result of the t-th iteration. t This represents the cumulative reconstruction in the t-th iteration.

[0236] If the sample counter t ≤ 16, then t = t + 1, and proceed to Step 2 for calculation; otherwise, the calculation process terminates, and the final reconstructed Demura data table x is generated. 16 It is sent to the Demura compensation module for Demura compensation calculation.

[0237] In summary, the present invention provides a DeMura table data compression and decompression method and apparatus based on RNN neural network. By utilizing RNN neural network to automatically learn the inherent correlation of DeMura data table, the traditional method eliminates the need for a large amount of expert human resources to manually screen correlation features, greatly simplifying the development and optimization process of the entire compression and decompression algorithm, shortening the development time and cost of OLED screen products, and improving the compression ratio.

[0238] Compared with the prior art, the present invention has the following advantages:

[0239] 1. This is the first time that an RNN neural network has been implemented in the Demura data table compression and decompression application.

[0240] 2. Randomly collect and construct the training set, eliminating the risk of inconsistency between the samples and the actual production line caused by the manual selection in traditional methods.

[0241] 3. By utilizing RNN neural networks for automatic learning, the traditional method eliminates the need for extensive expert manpower to manually screen relevant features, greatly simplifying the development and optimization of the entire compression and decompression algorithm and shortening the time and cost of OLED screen product development and production.

[0242] 4. The present invention has a compression efficiency of up to 32 times, and the FlashROM space saving cost advantage is obvious.

[0243] 5. This invention reduces the correlation between blocks by dividing the Demura data table sample into blocks, with each block being compressed and stored independently. The decompression process can reduce the use of buffer space and is easy to implement in low-cost hardware.

[0244] The above embodiments are merely illustrative of the principles and effects of the present invention and are not intended to limit the invention. Any person skilled in the art can make modifications and changes to the above embodiments without departing from the spirit and scope of the invention. Therefore, the scope of protection of the present invention should be as set forth in the claims.

Claims

1. A method for compressing and decompressing DeMura table data based on an RNN neural network, comprising the following steps: Step S1: Randomly collect several Demura data table samples from OLED displays to construct a Demura data table training set; Step S2: Establish an RNN neural network to automatically learn the inherent correlation of the Demura data table. Use the sample data of the Demura data table training set to train the model and obtain a trained Demura data table compression and decompression model. Step S3: Apply the Demura data table compression and decompression model obtained in step S2 to compress and decompress any Demura data table.

2. The DeMura table data compression and decompression method based on RNN neural network as described in claim 1, characterized in that: In step S1, a certain number of mura image samples of OLED displays are randomly collected from the current OLED production line, and Demura data table samples are calculated using the Demura algorithm to construct the Demura data table training set.

3. The DeMura table data compression and decompression method based on RNN neural network as described in claim 1, characterized in that, Step S2 further includes: Step S200: Randomly initialize the initial training set sample index; Step S201: Read a Demura data table sample in order according to the randomly shuffled sample index; Step S202: The read Demura data table sample is compressed using a feature encoder and a binarization encoder to generate a binarized encoded bitstream of the Demura data table. Step S203: Decompress the binarized encoded bitstream of the Demura data table using a decoder; Step S204: Calculate the residual based on the decompression result and the sample input data obtained in step S201; Step S205: After a preset number of iterations, calculate the total error of the compression and decompression process within that number of iterations; Step S206: After the training set has been sampled, calculate the average error of the current training and determine whether to continue training or end the training process based on the average error of the current training.

4. The DeMura table data compression and decompression method based on RNN neural network as described in claim 3, characterized in that: In step S201, the read Demura data table sample is divided into blocks.

5. The DeMura table data compression and decompression method based on RNN neural network as described in claim 4, characterized in that: In step S202, the feature encoder processes the Demura data table sample data through one CNN convolution E-Conv and three RNN convolutions. The kernel size of each convolution is 3×3 and the stride is 2×2. The RNN convolution uses the classic LSTM model.

6. The DeMura table data compression and decompression method based on RNN neural network as described in claim 5, characterized in that: The binary encoder processes the output of the feature encoder through a CNN convolution B-Conv with a kernel size of 1×1 and a stride of 1×1.

7. The DeMura table data compression and decompression method based on RNN neural network as described in claim 6, characterized in that: In step S206, if the sample counter i < M, where M is the total number of samples in the training set, then i = i + 1, and jump to step S201 to continue reading the next sample for compression and decompression training. If the sample counter i ≥ M, then the average error of the current training is calculated using the total error obtained in step S205.

8. The DeMura table data compression and decompression method based on RNN neural network as described in claim 7, characterized in that: If the average error Err ≥ δ, where δ represents the preset threshold, then proceed to step S200 to continue the model training process; if the average error Err < δ, then save the trained model weight parameters to files respectively, end the training process, and obtain the trained Demura data table compression and decompression model.

9. The DeMura table data compression and decompression method based on RNN neural network as described in claim 7, characterized in that: In step S3, the compression application includes the following steps: Step S300: Read any Demura data table and perform block partitioning; Step S301: The Demura data table samples after block division in step S300 are compressed using a feature encoder and a binarization encoder to generate a binarized encoded bitstream of the Demura data table. Step S302: Decompress the binarized encoded bitstream of the Demura data table obtained in step S201 using a decoder; Step S303: Calculate the residual based on the decompression result and the sample input data obtained in step S301; Step S304: After a preset number of iterations, save the binarized encoded bitstream of the Demura data table generated in step S301 to the FlashRom of the OLED screen module.

10. A DeMura table data compression and decompression device based on an RNN neural network, comprising: The training set construction unit is used to randomly collect Demura data table samples from several OLED displays and construct the Demura data table training set. The model building and training unit is used to build an RNN neural network to automatically learn the inherent correlation of the Demura data table. The model is trained using sample data from the Demura data table training set to obtain a trained Demura data table compression and decompression model. The compression and decompression application unit is used to apply the compression and decompression model of the Demura data table obtained by the model building and training unit to any Demura data table.

Images