User habit-based application recommendation method, mobile terminal, and storage medium

Abstract

The present invention provides a user habit-based application (app) recommendation method, a mobile terminal, and a storage medium. The method comprises the steps of: collecting user inherent attribute information, app interaction information, and location information, performing analysis and quantification, then performing marking, and establishing user interaction scenario information; collecting input information during app interaction, and recording the input information as interaction associated data on the basis of a corresponding time period and an app package name; processing the interaction associated data via a first neural network, and outputting emotional classification; processing the interaction scenario information via a second neural network, and outputting real label probability distribution information; matching reference interaction scenarios in a corpus according to the real label probability distribution information, and finding corresponding apps; and performing emotional classification on the reference interaction scenarios of the apps on the basis of an SVM algorithm, and recommending to a user the app conforming to an emotional classification tendency. In this way, a user is helped to screen for the app fitting the app interaction habit of the user, and the time cost of searching for the app by the user is reduced.

Description

Methods for recommending applications based on user habits, mobile terminals, and storage media. Technical Field

[0001] This invention relates to application recommendation technology, and more particularly to a method, mobile terminal, and storage medium for recommending applications based on user habits. Background Technology

[0002] Cloud phones, also known as virtual phones or mobile cloud services, are an innovative form of cloud computing service. They allow users to remotely access and control a virtual smartphone running on servers in a data center. Users can access the cloud phone through any internet-connected device, such as a personal computer, tablet, or another smartphone, overcoming geographical and hardware limitations to perform various computing tasks.

[0003] The core technology of cloud phones is based on virtualization. For example, it creates virtual Android or other operating system environments on servers, allowing users to install applications, games, and more, just like operating a physical phone. All computation and data storage occur in the cloud, and users control the virtual phone's interface via a network connection. Therefore, a cloud phone is essentially another giant mobile phone, allowing users to download and install virtually unlimited apps to meet their diverse needs.

[0004] However, there are currently a huge number and variety of apps, and their descriptions and definitions are not very clear. Therefore, it is difficult to find an app that suits a user's needs by simply looking at the text description. As a result, the entire search process is very time-consuming. In addition, each app store has its own management of apps, which leads to many apps being shelved, making it difficult for users to find an app that suits their needs.

[0005] Summary of the Invention

[0006] Therefore, the main objective of this invention is to provide a method, mobile terminal, and storage medium for recommending applications based on user habits, so as to help users filter out apps that fit their application interaction habits and reduce the time cost for users to find applications.

[0007] To achieve the above objectives, according to one aspect of the present invention, a method for recommending applications based on user habits is provided, comprising the steps of:

[0008] Collect user-specific attribute information, application interaction information, and location information, analyze and quantify them, then label them to establish user interaction scenario information;

[0009] Collect input information during application interaction and record it as interaction-related data according to the corresponding time period and application package name;

[0010] The first neural network processes the interactive data and outputs a sentiment classification.

[0011] The interaction scenario information is processed by the second neural network, which outputs the true label probability distribution information.

[0012] Based on the real label probability distribution information, various reference interaction scenarios are matched in the corpus to find the corresponding application.

[0013] Based on the SVM algorithm, sentiment classification is performed on reference interaction scenarios of each application, and applications that match the sentiment classification are recommended to users.

[0014] In a possible preferred embodiment, the method for recommending applications based on user habits further includes the following steps:

[0015] When a user uses a recommended application, the corresponding interaction scenario is stored in the corpus as a reference interaction scenario.

[0016] In a possible preferred embodiment, the step of analyzing and quantifying the data before labeling it to establish the user interaction scenario includes:

[0017] Based on application interaction information and user-specific attribute information, calculate the application's functional complexity F, interface complexity A, data input and processing complexity I, and context and personalization complexity Ctx;

[0018] Based on the four dimensions F, A, I, and Ctx, a linear regression model is used to map to a preset scene complexity level, and the scene complexity c of the corresponding level is fitted.

[0019] Concatenate the application package name in the application interaction information with the current application interaction interface scene to create a scene name;

[0020] The continuous usage time recorded in the application interaction information within the application interface scene is taken as the dwell time t.

[0021] The scene name is defined by the dwell time t, scene complexity c, location information, and user-specific attribute information. Pre-defined category tags are also assigned to the scene name to establish user interaction scenes.

[0022] In a possible preferred embodiment, the calculation process of functional complexity F includes:

[0023] Based on the number of clicks (C1), the number of swipes (SW), and the median interval (MI) recorded in the application interaction information, calculate: F = w1*CI + w2*SW + w3*(1 / (MI+1))

[0024] Among them, w1, w2, and w3 are the weights of the number of clicks, the number of swipes, and the median interval, respectively.

[0025] In a possible preferred embodiment, the calculation process for interface complexity A includes:

[0026] Based on the application interaction information recorded in the application, including the number of controls (Awiget), layout hierarchy (Alayout), interaction path length (Arow), animation effect (Aaim), clickable area size (Ainput), and text length (Atxt), calculate: A = Awiget * w1 + Alayout * w2 + Arow * w3 + Aaim * w4 + Ainput * w5 + Atxt * w6

[0027] Where w1 to w6 are the weights of the number of controls, layout hierarchy, interaction path length, animation effect, clickable area size, and text length, respectively.

[0028] In a possible preferred embodiment, the process of calculating data input and processing complexity I includes:

[0029] Based on the application's response time RT, memory usage MU, and CPU utilization CU recorded in the application interaction information, calculate: I = RT * (1 - M free )*w1+MU*w2+CU*w3

[0030] Where M free The percentage of remaining memory is M, and w1 is an adjustment parameter. free If it is less than 20%, then the value of w1 is less than 30%. w2 = 0.2 w3 = 1 - w2 - w1

[0031] Among them, w2 to w3 are the weights of memory usage and CPU utilization, respectively.

[0032] In a possible preferred embodiment, the calculation process for the context and personalization complexity Ctx includes:

[0033] Analyze user's inherent attribute information to extract the number of user preference types P and the importance ratio of user preference types Ct.

[0034] Analyze application interaction information, extract the number of rules r and the complexity of rules z, and calculate the number of rules and complexity R = a*r*z by adjusting the preset rule parameter a;

[0035] Computational context and individual complexity: Ctx = w1*P + w2*R + w3*Ct

[0036] Where w1, w2, and w3 are weight adjustment parameters.

[0037] In a possible preferred embodiment, the input information during the application interaction process includes at least one type of input information: voice or text.

[0038] To achieve the above objectives, corresponding to the above method, according to another aspect of the present invention, a system for recommending applications based on user habits is also provided, comprising:

[0039] The data acquisition unit is used to collect user-specific attribute information, application interaction information, and location information from the user terminal; as well as to collect input information during the application interaction process, and record it as interaction-related data according to the corresponding time period and application package name.

[0040] The analysis unit is used to concatenate the application package name in the application interaction information with the current application interaction interface scene to establish a scene name; analyze and quantify the application interaction information and user inherent attribute information, calculate the scene complexity c, and use the dwell time t and location information, user inherent attribute information, and scene complexity c obtained from the application interaction information as attributes of the scene name.

[0041] The hybrid neural network unit includes: a rule-based system, an RNN network, and a CNN network. The rule-based system is used to assign preset classification labels to scene names to establish user interaction scenes. The RNN network is used to process interaction-related data and obtain sentiment classification. The CNN network is used to obtain real label probability distribution information based on interaction scene information. The rule-based system, based on the real label probability distribution information, matches each reference interaction scene in its corpus according to keywords, finds the corresponding application, and performs sentiment classification on the reference interaction scenes of each application based on the SVM algorithm. Applications that match the sentiment classification tendency are recommended to users. When a user uses a recommended application, the corresponding interaction scene is stored in the corpus as a reference interaction scene.

[0042] To achieve the above objectives, in accordance with the above methods, according to another aspect of the present invention, a computer-readable storage medium is also provided, the computer-readable storage medium storing a computer program, wherein when the computer program is executed, it implements the steps of the method for recommending applications based on user habits as described above.

[0043] The method, mobile terminal, and storage medium for recommending applications based on user habits provided by this invention ingeniously design a scheme for analyzing and quantifying users' inherent attribute information, application interaction information, and location information. This allows for the construction of user interaction scenario information suitable for neural network recognition after labeling, and the evaluation of apps tailored to individual user preferences and habits. Furthermore, to improve evaluation accuracy, the scheme incorporates sentiment analysis. By collecting user interaction correlation data, it further analyzes the user's sentiment classification in corresponding interaction scenarios, thereby more accurately identifying the user's intent and recommending apps that better match the user's application interaction habits and preferences, ultimately reducing the time cost for users to find applications. Attached Figure Description

[0044] The accompanying drawings, which form part of this application, are used to provide a further understanding of the invention. The illustrative embodiments of the invention and their descriptions are used to explain the invention and do not constitute an undue limitation of the invention. In the drawings:

[0045] Figure 1 is a schematic diagram of the method steps for recommending applications based on user habits according to the present invention;

[0046] Figure 2 is a conceptual diagram of constructing an interactive scenario in the method for recommending applications based on user habits of the present invention.

[0047] Figure 3 is a schematic diagram of the process of intent recognition by the hybrid neural network in the user habit recommendation application method of the present invention;

[0048] Figure 4 is a schematic diagram of the system structure of the user habit-based recommendation application of the present invention. Detailed Implementation

[0049] To enable those skilled in the art to better understand the technical solutions of the present invention, the specific technical solutions of the present invention will be clearly and completely described below in conjunction with embodiments, so as to help those skilled in the art further understand the present invention. Obviously, the embodiments described in this application are merely some embodiments of the present invention, and not all embodiments. It should be noted that, for those skilled in the art, the embodiments and features in the embodiments of this application can be combined with each other without departing from the concept of the present invention and without conflict. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort should fall within the disclosure and protection scope of the present invention.

[0050] Furthermore, the terms "first," "second," "S100," "S200," etc., used in the specification, claims, and drawings of this invention are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such features can be interchanged where appropriate so that embodiments of the invention described herein can be implemented in orders other than those described herein. At the same time, the stages described in each step are not necessarily to be implemented in the same step; it should be understood that the implementation order of the contents of each step stage can be adjusted and interchanged without violating the inventive concept, so that embodiments of the invention described herein can be implemented in orders other than those described herein. Additionally, the terms "comprising" and "having," and any variations thereof, are intended to cover non-exclusive inclusion. Unless otherwise expressly specified and limited, the terms "set," "arrange," "install," "connect," and "link" should be interpreted broadly. For example, they can refer to a fixed connection, a detachable connection, or an integral connection; a mechanical connection or an electrical connection; a direct connection or an indirect connection through an intermediate medium; or a connection within two elements. Those skilled in the art can understand the specific meaning of the above terms in this case based on the specific circumstances and in conjunction with existing technology.

[0051] To help users select apps that match their application interaction habits and reduce the time cost of searching for apps, as shown in Figures 1 to 3, this invention provides a method for recommending apps based on user habits, the steps of which include:

[0052] Step S100 collects user-specific attribute information, application interaction information, and location information, analyzes and quantifies them, and then labels them to establish user interaction scenario information; collects input information (such as voice and / or text input information) during the application interaction process, and records it according to the corresponding time period and application package name as interaction-related data.

[0053] Specifically, in this example, the user's inherent attribute information may include: age, gender, personal preferences, date of birth, etc. This information is relatively fixed with a low rate of change, easily quantifiable, and has a relatively small data volume. However, the user's application interaction information and location information are, on the one hand, constantly changing in real time and have a large data volume; on the other hand, the application interaction information is relatively abstract, and without data quantification, it is difficult to use as input to a neural network for subsequent intent recognition processing.

[0054] To address this, this invention designs an analytical quantification method. Conceptually, based on application interaction information and user-defined attribute information, it calculates the application's functional complexity F, interface complexity A, data input and processing complexity I, and context and personalization complexity Ctx. Then, based on the four dimensions of F, A, I, and Ctx, a linear regression model is used to map them to a preset scene complexity level. This allows for the fitting of a scene complexity c corresponding to the preset level, thereby quantifying application interaction information and describing user preferences for application interaction habits. Finally, the dwell time t, scene complexity c, location information, and user-defined attribute information are used as attributes of the scene name, and preset category labels are assigned to the scene name to establish user interaction scenes.

[0055] For example, first, the application package name in the application interaction information is concatenated with the current application interaction interface scene to create a scene name. For example, the scene name is concatenated with the current foreground application package name and the string of the current application interaction interface to form a scene name containing package name-interface name (e.g., com.example.demo-activity).

[0056] This yields the scene name of the current user's interactive scenario, which is assigned two attributes: dwell time t and scene complexity c. Dwell time t is the continuous usage time recorded in the application interaction information within the application's interactive interface scenario, while scene complexity c is divided into five levels from 1 to 5 in this example. In practice, those skilled in the art can adjust the levels as needed.

[0057] The calculation process for functional complexity F includes:

[0058] The functional complexity F is calculated based on the number of clicks (C1), the number of swipes (SW), and the median interval (MI) recorded in the application interaction information. Where:

[0059] Click count C1: This refers to the number of clicks performed by a user while using the app. A higher click count may indicate that a functional module is more complex, as users need to perform multiple clicks to complete a specific function.

[0060] Swipe count (SW): This refers to the number of swipes a user makes while using the app. Similar to click count, a higher swipe count may indicate that a functional module has a relatively complex operation process, requiring more swipes to complete a specific function.

[0061] Median Interval (MI): This refers to the median time interval between consecutive user actions. A shorter median interval may indicate a more compact and continuous workflow for a functional module, while a longer median interval may indicate more waiting or delays during the operation.

[0062] By considering these metrics, the complexity of the application functions used by users can be assessed more comprehensively. Functional modules with higher click counts, swipe counts, and shorter median intervals can be considered to have higher complexity. Therefore, the functional complexity F is calculated as: F = w1*CI + w2*SW + w3*(1 / (MI+1)).

[0063] Here, w1, w2, and w3 are the weights of the number of clicks, the number of swipes, and the median interval, respectively. The number of clicks (CI) and the number of swipes (SW) use the actual values, while the median interval (MI) is calculated by adding 1 and taking the reciprocal.

[0064] The calculation process for interface complexity A includes:

[0065] Based on the application interaction information recorded, including the number of controls Awiget, layout hierarchy Alayout, interaction path length Arow, animation effect Aaim, clickable area size Ainput, and text length Atxt, calculate the interface complexity A.

[0066] Interface complexity A refers to the complexity and ease of use of a user interface or application. Interface complexity is evaluated and quantified from the following aspects:

[0067] The number of controls (Awiget): The more controls there are on the screen, the more elements the user needs to focus on and interact with. For example, you can use the getChildCount() method of ViewGroup to get the number of controls.

[0068] Layout hierarchy (Alayout): The deeper the layout hierarchy of the interface, the more complex the nested structure of the interface. Deeply nested layouts increase the complexity and time of UI rendering, for example, by using the ViewGroup's getChildCount() method.

[0069] Interaction path length (Arow): The number of steps a user needs to take to complete a specific task. If a user needs to go through multiple pages or interfaces to complete a task, the interaction path length is long and the interface complexity is high. For example, it can be obtained by recording the ClickEvent method and by overriding the dispatchTouchEvent method of the control to record the event dispatch path internally. The sum of these two values ​​is the interaction path length.

[0070] Animation effects (Aaim): Too many or complex animation effects can cause visual impact and cognitive burden on users. For example, you can use the View's getAnimation() method to obtain them.

[0071] Clickable area size (Ainput): The size of the clickable area in the interface affects the user's touch precision and operation accuracy, for example, by recording the ClickEvent method.

[0072] Text Length (Atxt): Excessively long text in the interface increases the difficulty for users to read and understand. Concise and clear text improves usability, for example, by using the View method.

[0073] Therefore, the interface complexity A is calculated as follows: A = Awiget * w1 + Alayout * w2 + Arow * w3 + Aaim * w4 + Ainput * w5 + Atxt * w6.

[0074] Where w1 to w6 are the weights of the number of controls, layout hierarchy, interaction path length, animation effect, clickable area size, and text length, respectively.

[0075] The calculation process for data input and processing complexity I includes:

[0076] Based on the application's response time RT, memory usage MU, and CPU utilization CU recorded in the application interaction information, calculate the data input and processing complexity I. Where:

[0077] Response time (RT): This refers to the time taken to determine the complexity of a system. Since response time is also determined by memory, it needs to be adjusted according to the system's memory requirements.

[0078] Memory Usage (MU): Memory usage reflects the complexity of the current scenario to some extent. When memory usage is high, it indicates that the current scenario is more complex and requires more resources.

[0079] CPU utilization (CU: CPU Usage): CPU utilization is a relatively intuitive indicator of the complexity of the current scene. When the utilization is high (including input content and data processing algorithms), the current scene is complex.

[0080] In summary: Response time is affected by the system's remaining memory (M free The data input and processing complexity I is directly reflected in CPU utilization, while the CPU utilization rate is directly affected by the data input and processing complexity. Therefore, the data input and processing complexity I is calculated as: I = RT * (1 - M) free )*w1+MU*w2+CU*w3

[0081] Where M free The percentage of remaining memory is M, and w1 is an adjustment parameter. free If it is less than 20%, then the value of w1 is less than 30%. w2 = 0.2 w3 = 1 - w2 - w1

[0082] Among them, w2 to w3 are the weights of memory usage and CPU utilization, respectively.

[0083] The calculation process for context and personalization complexity Ctx includes:

[0084] Analyze user-defined attribute information to extract the number of user preference types P and the importance weight Ct of each preference type; analyze application interaction information to extract the number of rules r and the complexity z of each rule, and calculate the number of rules and complexity R = a*r*z with the preset rule adjustment parameter a, and calculate the context and personalization complexity Ctx. Where:

[0085] Number of user preference types (P): This can be represented by the quantity and diversity of a user's personal attributes and related preferences. In other words, it refers to the individual descriptive tags for each user, such as when an app first launches and asks the user to select their preferred domain tags.

[0086] Number and complexity of rules (R): can be expressed as the number and complexity of rules, and can be quantified by the following formula: R = a * r * z.

[0087] Where 'a' represents the weight parameter of the number of rules and the complexity of the rules, 'r' represents the number of rules, and 'z' represents the complexity of the rules. The complexity of the rules here is a specific value that needs to be experienced to implement user tags. It is given by the system and will be updated after a period of time.

[0088] The importance of contextual information (Ct) can be represented as a specific numerical value for the importance of contextual information extracted from a user's personal attributes and related preferences. That is, when an application is detected to contain a tag related to a user's selected personal attributes and related preferences, the weight of that tag increases within the overall user tags. For example, user data is initially collected, and this data is ultimately presented as a tag plus a percentage. The percentage is calculated as (1 / total number of tags). When a user's behavior is detected to contain a tag matching the user's selected personal attributes and related preferences, the value increases, while the values ​​of other tags decrease. The specific addition or subtraction is one percent of the total number of tags (±1 / (100 * total number of tags)).

[0089] Therefore, the context and individual complexity Ctx is calculated as: Ctx = w1*P + w2*R + w3*Ct

[0090] w1, w2, and w3 are weight adjustment parameters, which are specified according to the system settings.

[0091] Finally, the four dimensions obtained (functional complexity F, interface complexity A, data input and processing complexity I, and context and personalization complexity Ctx) are mapped to scene complexity levels (1, 2, 3, 4, 5). A linear regression model can be used, as follows:

[0092] The scene complexity level c = w1*F + w2*A + w3*I + w4*Ctx + b.

[0093] Here, w1, w2, w3, and w4 are the weight parameters corresponding to each dimension, and b is the bias term. Throughout the fitting process, the least squares method is used to adjust the weight parameters and bias term, ultimately obtaining the scene complexity c at the corresponding level. This is used to quantify application interaction information to describe user preferences for application interaction habits.

[0094] Then, the dwell time t, scene complexity c, location information and user inherent attribute information are used as attributes of the scene name, and preset category tags are assigned to the scene name to establish user interaction scenes.

[0095] For example, a series of tags can be preset, such as: Taobao shopping, strategy games, novels, card games, and cultivation. These tags will be updated synchronously with current market applications and internet buzzwords. Initially, a portion of the tags will have a pre-defined mapping relationship with scene names. Subsequent tags will be assigned using an SVM (Single Vector Machine) to associate the corresponding tags with scene names. This establishes a user interaction scene with a data structure similar to the following.

[0096] com.example.demo-activity:

[0097] Labels: Taobao shopping, strategy games, novels, card games, cultivation (immortal cultivation)

[0098] t: 120s

[0099] c:2

[0100] location: 31.2304°N,121.4737°E

[0101] age:18

[0102] m:m

[0103] fov: Self-introduction

[0104] br:19930706

[0105] com.example.demo-activity2:

[0106] Labels: Taobao shopping, novels, card games, cultivation

[0107] t: 120s

[0108] c:2

[0109] location: 31.2304°N,121.4737°E

[0110] age:18

[0111] m:m

[0112] fov: Self-introduction

[0113] br:19930706

[0114] Furthermore, in an alternative implementation, since the labels are finite and highly repetitive, and since the entire process records data over a period of time, the labels corresponding to the labels can be Huffman encoded, and then Huffman restored before the data is fed into the hybrid neural network. Thus, the above example evolves into the following:

[0115] com.example.demo-activity:

[0116] Labels: 1, 3, 27, 15, 9

[0117] t: 120s

[0118] c:2

[0119] location: 31.2304°N,121.4737°E

[0120] age:18

[0121] m:m

[0122] fov: Self-introduction

[0123] br:19930706

[0124] com.example.demo-activity2:

[0125] Label: 1, 27, 15, 9

[0126] t: 120s

[0127] c:2

[0128] location: 31.2304°N,121.4737°E

[0129] age:18

[0130] m:m

[0131] fov: Self-introduction

[0132] br:19930706

[0133] In step S200, the interaction-related data is processed by the first neural network to output the sentiment classification; the interaction scene information is processed by the second neural network to output the true label probability distribution information.

[0134] Specifically, as shown in Figure 3, in order to provide a basis for recognizing user intent and output an APP that matches user preferences, this example uses a hybrid neural network to process the interaction-related data and interaction scene information obtained in step S100. The first neural network is preferably an RNN recurrent neural network, which performs sentiment analysis on the user's voice, text, and time-based interaction-related data and outputs the results.

[0135] For example, for RNNs, labeled binary audio files or a text segment can be used as input for training.

[0136] Unhappy: 'A binary voice message' | 'A piece of text'.

[0137] Therefore, when user interaction data is input into the RNN, a sentiment classification is directly obtained and fed back into the rule system.

[0138] The second neural network is preferably a CNN convolutional neural network. First, the following interaction scenario information is input into the CNN network:

[0139] com.example.demo-activity:

[0140] Labels: Taobao shopping, strategy games, novels, card games, cultivation (immortal cultivation)

[0141] t: 120s

[0142] c:2

[0143] location: 31.2304°N,121.4737°E

[0144] age:18

[0145] m:m

[0146] fov: Self-introduction

[0147] br:19930706

[0148] com.example.demo-activity2:

[0149] Labels: Taobao shopping, novels, card games, cultivation

[0150] t: 120s

[0151] c:2

[0152] location: 31.2304°N,121.4737°E

[0153] age:18

[0154] m:m

[0155] fov: Self-introduction

[0156] br:19930706

[0157] Here, label, t, c, and location are highly variable values. Therefore, the pre-trained word embedding model Word2Vec is used to map words or subwords to real-valued vectors. CNN data preprocessing is performed as follows:

[0158] This allows us to input `label_embedding`, `t_embedding`, `c_embedding`, and `location_embedding` into the CNN for training, i.e., into the convolutional layers. The training function chosen is the cross-entropy loss function because the CNN outputs a unique series of feature vectors. Therefore, the cross-entropy loss transforms the feature values ​​of each feature vector into a probability distribution based on the true label. In other words, it transforms 'Taobao shopping' in the sample into 'clothes (60%) c2', thus providing the output true label probability distribution information to the rule system for matching.

[0159] Step S300 involves matching each reference interaction scenario in the corpus based on the real label probability distribution information and finding the corresponding application; performing sentiment classification on the reference interaction scenarios of each application based on the SVM algorithm, and recommending applications that match the sentiment classification tendency to the user.

[0160] Specifically, after obtaining the sentiment classification and true label probability distribution information output in step S200, the user's intent can be identified. In this example, the intent identification is divided into three parts:

[0161] Rule-based systems serve two purposes:

[0162] 'a' has a constantly updated term library. If the term appears in the tag data or in the speech or text, the corresponding scene construction rules will be triggered directly.

[0163] b determines whether the results of CNN and RNN can be used to construct scene rules. If so, output them directly; otherwise, feed them back to the original address. The method for this determination is the vocabulary database in a.

[0164] The corresponding rule-based systems are as follows:

[0165] 1) Corpus:

[0166] For example, by using channels or other existing technologies, obtain a continuously updated tag library from the current network and associate the corresponding tags with package names and interface names.

[0167] Cultivation: (c1: [com.example.app1-activity1, com.example.app1-activity2]);

[0168] Dress: (c2:[com.example.app3-activity1, com.example.app5-activity2]);

[0169] Sports car: (c3:[com.example.app4-activity2, com.example.app1-activity5]).

[0170] 2) Rules:

[0171] 1. Use regular expressions for keyword matching

[0172] For example, when a CNN outputs the true label probability distribution information, it will run through a regular expression to match the reference interaction scenario in the corpus. When a match is found, it will directly output the current true label probability distribution information.

[0173] For example, if the CNN outputs 'clothes (60%) c2' and 'skirt (70%) c2', it can match: dress: (com.example.app3-activity1, com.example.app5-activity2). Then the package name-interface name (scene name) corresponding to the dress can be obtained, thus finding the corresponding APP.

[0174] 2. SVM-based sentiment classification

[0175] The user's sentiment classification tendency has already been known through RNN. At this time, the reference interaction scenario corresponding to the matched APP is input into the trained SVM to classify according to sentiment. APPs that match the user's sentiment tendency are recommended to the user or installed in the user's scenario, thereby completing the application recommendation based on user habits.

[0176] The above SVM training process is exemplified as follows:

[0177] Build a sample library: the sentiment tags of package name-interface name (scene name) can be considered to cover all sentiment descriptions.

[0178] Datafication of Samples: Word Segmentation: Dividing the text into individual words or phrases. Vocabulary Construction: Constructing a vocabulary containing all words appearing in the text. Feature Vector Representation: For each text, marking the frequency of a word's occurrence in its corresponding position in the feature vector based on the words in the vocabulary, or using binary values ​​to represent whether it appears. Text Vectorization: Using the feature vector of each text as its numerical feature representation.

[0179] Preprocessing: Add or remove relevant words to ensure that text vectorization can be performed normally, that is, ensure that the emotional tags of package name-interface name can be converted into numerical values.

[0180] Training: The sentiment label of each package name-interface name is used as the target variable for classification. A corresponding sentiment model is trained. That is, if a label is input, the numerical features of the sentiment will be output, which will eventually be converted into sentiment words.

[0181] 3) Testing and optimization:

[0182] This section is divided into two parts. First, the corpus can be set to be updated in real time. The continuously updated data means that more complex data will be processed. Second, the rules can be periodically corrected using manually determined text.

[0183] In an optional implementation, when a user uses the recommended application (APP), the recommendation is considered successful, and the corresponding interaction scenario can be stored in the corpus as a reference interaction scenario.

[0184] On the other hand, corresponding to the above method example, as shown in Figure 4, the present invention also provides a system for recommending applications based on user habits, which includes:

[0185] The data acquisition unit is used to collect user-specific attribute information, application interaction information, and location information from the user terminal; as well as to collect input information during the application interaction process, and record it as interaction-related data according to the corresponding time period and application package name.

[0186] The analysis unit is used to concatenate the application package name in the application interaction information with the current application interaction interface scene to establish a scene name; analyze and quantify the application interaction information and user inherent attribute information, calculate the scene complexity c, and use the dwell time t and location information, user inherent attribute information, and scene complexity c obtained from the application interaction information as attributes of the scene name.

[0187] The hybrid neural network unit includes: a rule-based system, an RNN network, and a CNN network. The rule-based system is used to assign preset classification labels to scene names to establish user interaction scenes. The RNN network is used to process interaction-related data and obtain sentiment classification. The CNN network is used to obtain real label probability distribution information based on interaction scene information. The rule-based system, based on the real label probability distribution information, matches each reference interaction scene in its corpus according to keywords, finds the corresponding application, and performs sentiment classification on the reference interaction scenes of each application based on the SVM algorithm. Applications that match the sentiment classification tendency are recommended to users. When a user uses a recommended application, the corresponding interaction scene is stored as a reference interaction scene in the corpus.

[0188] On the other hand, the present invention also provides a computer-readable storage medium storing a computer program, wherein when the computer program is executed, it implements the steps of the method for recommending applications based on user habits as described above.

[0189] In summary, the method, mobile terminal, and storage medium for recommending applications based on user habits provided by this invention ingeniously design a scheme for analyzing and quantifying users' inherent attribute information, application interaction information, and location information. This allows for the construction of user interaction scenario information suitable for neural network recognition after labeling, and the evaluation of apps tailored to individual user preferences and habits. Furthermore, to improve evaluation accuracy, the scheme incorporates sentiment analysis. By collecting user interaction correlation data, it further analyzes the user's sentiment classification in corresponding interaction scenarios, thereby more accurately identifying the user's intent and recommending apps that better match the user's habits and preferences, ultimately reducing the time cost for users to find applications.

[0190] The preferred embodiments of the present invention disclosed above are merely illustrative of the invention. These preferred embodiments do not exhaustively describe all details, nor do they limit the invention to the specific implementations described. Clearly, many modifications and variations can be made based on the content of this specification. This specification selects and specifically describes these embodiments to better explain the principles and practical applications of the invention, thereby enabling those skilled in the art to better understand and utilize the invention. The present invention is limited only by the claims and their full scope and equivalents. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the invention should be included within the protection scope of the invention.

[0191] Those skilled in the art will understand that, besides implementing the system, apparatus, unit, and its modules provided by this invention in purely computer-readable program code, the same program can be implemented in the form of logic gates, switches, application-specific integrated circuits, programmable logic controllers, and embedded microcontrollers by logically programming the method steps. Therefore, the system, apparatus, and its modules provided by this invention can be considered a hardware component, and the modules included therein for implementing various programs can also be considered structures within the hardware component; alternatively, modules for implementing various functions can be considered both software programs implementing the method and structures within the hardware component.

[0192] Furthermore, all or part of the steps in the methods of the above embodiments can be implemented by a program instructing related hardware. This program is stored in a storage medium and includes several instructions to cause a microcontroller, chip, or processor to execute all or part of the steps of the methods described in the various embodiments of this application. The aforementioned storage medium includes various media capable of storing program code, such as a USB flash drive, a portable hard drive, a read-only memory (ROM), a random access memory (RAM), a magnetic disk, or an optical disk.

[0193] Furthermore, various different implementations of the present invention can be combined arbitrarily, as long as they do not violate the spirit of the present invention, they should also be regarded as the content disclosed in the present invention.

Claims

1. A method for recommending applications based on user habits, including the following steps: Collect user-specific attribute information, application interaction information, and location information, analyze and quantify them, then label them to establish user interaction scenario information; Collect input information during application interaction and record it as interaction-related data according to the corresponding time period and application package name; The first neural network processes the interactive data and outputs a sentiment classification. The interaction scenario information is processed by the second neural network, which outputs the true label probability distribution information. Based on the real label probability distribution information, various reference interaction scenarios are matched in the corpus to find the corresponding application. Based on the SVM algorithm, sentiment classification is performed on reference interaction scenarios of each application, and applications that match the sentiment classification are recommended to users.

2. The method for recommending applications based on user habits according to claim 1, wherein the steps further include: When a user uses a recommended application, the corresponding interaction scenario is stored in the corpus as a reference interaction scenario.

3. The method for recommending applications based on user habits according to claim 1, wherein the step of analyzing and quantifying the data and then tagging it to establish user interaction scenarios includes: Based on application interaction information and user-specific attribute information, calculate the application's functional complexity F, interface complexity A, data input and processing complexity I, and context and personalization complexity Ctx; Based on the four dimensions F, A, I, and Ctx, a linear regression model is used to map to a preset scene complexity level, and the scene complexity c of the corresponding level is fitted. Concatenate the application package name in the application interaction information with the current application interaction interface scene to create a scene name; The continuous usage time recorded in the application interaction information within the application interface scene is taken as the dwell time t. The scene name is defined by the dwell time t, scene complexity c, location information, and user-specific attribute information. Pre-defined category tags are also assigned to the scene name to establish user interaction scenes.

4. The method for recommending applications based on user habits according to claim 3, wherein the calculation process of functional complexity F includes: Based on the click count C1, swipe count SW, and median interval MI recorded in the application interaction information, calculate: F=w1*CI+w2*SW+w3*(1 / (MI+1)), Among them, w1, w2, and w3 are the weights of the number of clicks, the number of swipes, and the median interval, respectively.

5. The method for recommending applications based on user habits according to claim 3, wherein the calculation process of interface complexity A includes: Based on the application interaction information recorded in the application, including the number of controls (Awiget), layout hierarchy (Alayout), interaction path length (Arow), animation effect (Aaim), clickable area size (Ainput), and text length (Atxt), calculate: A=Awiget*w1+Alayout*w2+Arow*w3+Aaim*w4+Ainput*w5+Atxt*w6, Where w1 to w6 are the weights of the number of controls, layout hierarchy, interaction path length, animation effect, clickable area size, and text length, respectively.

6. The method for recommending applications based on user habits according to claim 3, wherein the calculation process of data input and processing complexity I includes: Based on the application's response time RT, memory usage MU, and CPU utilization CU recorded in the application interaction information, calculate: I=RT*(1-M free )*w1+MU*w2+CU*w3, Where M free The percentage of remaining memory is M, and w1 is an adjustment parameter. free If it is less than 20%, then the value of w1 is less than 30%. w2＝0.2； w3 = 1 - w2 - w1, Among them, w2 to w3 are the weights of memory usage and CPU utilization, respectively.

7. The method for recommending applications based on user habits according to claim 3, wherein the calculation process of context and personalization complexity Ctx includes: Analyze user's inherent attribute information to extract the number of user preference types P and the importance ratio of user preference types Ct. Analyze application interaction information, extract the number of rules r and the complexity of rules z, and calculate the number of rules and complexity R = a*r*z by adjusting the preset rule parameter a; Computational context and personalized complexity: Ctx = w1*P + w2*R + w3*Ct, Where w1, w2, and w3 are weight adjustment parameters.

8. The method for recommending applications based on user habits according to claim 1, wherein the input information during the application interaction process includes: Input information of at least one of the following: voice or text.

9. Systems that recommend applications based on user habits, including: The data acquisition unit is used to collect user-specific attribute information, application interaction information, and location information from the user terminal. And collect input information during application interaction, record it according to the corresponding time period and application package name as interaction-related data; The analysis unit is used to concatenate the application package name in the application interaction information with the current application interaction interface scene to establish a scene name; Analyze and quantify application interaction information and user inherent attribute information, calculate scene complexity c, and use the dwell time t and location information, user inherent attribute information, and scene complexity c obtained from application interaction information as attributes of scene name; The hybrid neural network unit includes: a rule-based system, an RNN network, and a CNN network. The rule-based system is used to assign preset classification labels to scene names to establish user interaction scenes. The RNN network is used to process interaction-related data and obtain sentiment classification. The CNN network is used to obtain real label probability distribution information based on interaction scene information. The rule-based system, based on the real label probability distribution information, matches each reference interaction scene in its corpus according to keywords, finds the corresponding application, and performs sentiment classification on the reference interaction scenes of each application based on the SVM algorithm. Applications that match the sentiment classification tendency are recommended to users. When a user uses a recommended application, the corresponding interaction scene is stored in the corpus as a reference interaction scene.

10. A computer-readable storage medium storing a computer program, wherein when executed, the computer program implements the steps of the method for recommending applications based on user habits as described in any one of claims 1 to 8.

Images