Optimizing Data Processing for Model Lightweighting in HarmonyOS Next

Developing lightweight, efficient models for resource-constrained devices like those running HarmonyOS Next requires careful optimization, particularly in data processing. This post delves into techniques for enhancing data processing to reduce model size and improve performance, focusing on HarmonyOS Next (API 12).

I. Data Processing's Impact on Model Lightweighting

(1) Importance Analysis

Data processing is fundamental to model lightweighting. Think of it as preparing ingredients for a recipe – the quality and preparation directly impact the final product. Efficient processing removes noise and redundancy, allowing the model to focus on key features, thereby reducing training time and storage requirements.

(2) Impact on Model Training and Optimization

Impact on the Training Process

Data processing significantly affects model training. Improperly processed data can lead to longer training times and biased models. Techniques like normalization ensure data consistency, leading to faster convergence.

Impact on the Optimization Process

Data processing is equally vital for model optimization. For instance, in model pruning, outliers can lead to retaining less important neurons. Data cleaning helps ensure accuracy in identifying less important parts of the model.

(3) Examples of Data Processing Strategies and Their Impact

Data Sampling Strategy

Random downsampling can reduce training data, but inappropriate ratios might lead to information loss and reduced accuracy. Stratified sampling, on the other hand, preserves data diversity while reducing size. For instance, downsampling a 100,000-image dataset to 50,000 might reduce accuracy from 90% to 85% with random sampling, but only to 88% with stratified sampling.

Data Transformation Strategy

Transformations like image flipping and rotation increase data diversity and robustness. However, excessive transformations can cause overfitting. Moderate transformations are key to balancing diversity and accuracy. Example: Flipping every image in an animal picture dataset many times can drop accuracy from 92% to 89%, while flipping 0-1 times might raise it to 93%.

II. Data Augmentation and Preprocessing Technologies

(1) Data Augmentation Technologies

Flipping Operation

A simple yet effective technique for image data, horizontal or vertical flipping increases diversity. Example: In face recognition, this helps the model learn left-right symmetry.

import cv from '@ohos.multimedia.camera.cv';

// Load the image
let image = cv.imread('face_image.jpg');

// Horizontally flip the image
let flippedImage = cv.flip(image, 1); // 1 indicates horizontal flipping

// Save the flipped image
cv.imwrite('flipped_face_image.jpg', flippedImage);

Cropping Operation

Focuses the model on specific image regions, improving robustness. In object detection, random cropping helps the model recognize objects in various positions and sizes.

import cv from '@ohos.multimedia.camera.cv';

// Load the image
let image = cv.imread('car_image.jpg');

// Get the image size
let height = image.rows;
let width = image.cols;

// Define the cropping area (here it is assumed to crop the central area, and the size is half of the original image)
let x = width / 4;
let y = height / 4;
let cropWidth = width / 2;
let cropHeight = height / 2;

// Crop the image
let croppedImage = image.submat(y, y + cropHeight, x, x + cropWidth);

// Save the cropped image
cv.imwrite('cropped_car_image.jpg', croppedImage);

Rotation Operation

Simulates images at various angles. In digit recognition, rotating images helps the model recognize digits at different angles.

import cv from '@ohos.multimedia.camera.cv';

// Load the image
let image = cv.imread('digit_image.jpg');

// Get the center coordinates of the image
let center = new cv.Point(image.cols / 2, image.rows / 2);

// Define the rotation matrix, here rotate 30 degrees
let rotationMatrix = cv.getRotationMatrix2D(center, 30, 1);

// Perform the rotation operation
let rotatedImage = cv.warpAffine(image, rotationMatrix, new cv.Size(image.cols, image.rows));

// Save the rotated image
cv.imwrite('rotated_digit_image.jpg', rotatedImage);

(2) Data Preprocessing Methods

Normalization Method

Maps data to a specific range (e.g., 0-1 or -1-1). This ensures features are comparable and speeds up training. Example: In a housing price prediction model, it prevents features with larger values from dominating.

// Assume that features is a two-dimensional array, and each row represents the features of a sample
let maxValues = features[0].map((value) => value);
let minValues = features[0].map((value) => value);

// Find the maximum and minimum values of each feature
for (let i = 1; i < features.length; i++) {
    for (let j = 0; j < features[i].length; j++) {
        if (features[i][j] > maxValues[j]) {
            maxValues[j] = features[i][j];
        }
        if (features[i][j] < minValues[j]) {
            minValues[j] = features[i][j];
        }
    }
}

// Normalization operation
let normalizedFeatures = features.map((sample) => {
    return sample.map((value, index) => (value - minValues[index]) / (maxValues[index] - minValues[index]));
});

Standardization Method

Transforms data to a distribution with a mean of 0 and a standard deviation of 1. This is particularly useful for data with normal distribution characteristics. Example: Stock price prediction, where price fluctuations often follow a normal distribution.

import stats from '@ohos.stats';

// Assume that features is a two-dimensional array, and each row represents the features of a sample
let meanValues = [];
let stdDevValues = [];

// Calculate the mean and standard deviation of each feature
for (let j = 0; j < features[0].length; j++) {
    let sum = 0;
    for (let i = 0; i < features.length; i++) {
        sum += features[i][j];
    }
    meanValues.push(sum / features.length);

    let varianceSum = 0;
    for (let i = 0; i < features.length; i++) {
        varianceSum += Math.pow(features[i][j] - meanValues[j], 2);
    }
    stdDevValues.push(Math.sqrt(varianceSum / features.length));
}

// Standardization operation
let standardizedFeatures = features.map((sample) => {
    return sample.map((value, index) => (value - meanValues[index]) / stdDevValues[index]);
});

(3) Key Points for Optimizing Data Processing

The choice of augmentation strategies should align with the model type and application. Preprocessing parameters need adjustment based on data distribution, and handling outliers is crucial. Careful monitoring of performance indicators is essential to ensure optimization doesn't negatively impact results.

III. Case Study: Collaborative Optimization

(1) Case Background and Objectives

A plant recognition application on HarmonyOS Next aims to achieve lightweight model deployment while maintaining accuracy.

(2) Collaborative Optimization Process

The process included data augmentation (flipping, rotation, cropping), normalization, structured pruning (reducing model parameters by 50%), and quantization (reducing model size and increasing computational efficiency).

(3) Analysis of Performance Improvement Effects

Model accuracy increased from 85% to 90%, while model size decreased from 30MB to 5MB, and computational cost reduced by half (3 million to 1 million operations).

(4) Summary of Key Points and Precautions

The order of optimization matters: data processing first, then model structure optimization, and finally quantization. Data and model adaptation is crucial. Continuous performance monitoring helps identify and adjust optimization strategies.