4. Proposed Methodology

a. Methods for Definition and Pruning

Definition 4.1: The pattern-growth-based mining algorithm relies on extension as a crucial step. One kind of extension used in mining is the 𝑇-Extension, while the other is the 𝑎-Extensions. The 𝑆-Extension inserts a new item into the existing sequence by appending a new itemset to its end. Regarding 𝐽-Extension, it augments the current sequence by adding a new item to the last itemset. Adding these two expansions will undoubtedly cause the sequence to expand.

Definition 4.2: Targeted sequential pattern mining, as The study already established, does not have an algorithm. A post-processing strategy is required if the study intend to carry out this task using a conventional sequential pattern mining algorithm. As long as the sequential pattern was mined by SPM, this method will save the data. To find out if the created sequential pattern contains the question sequence, it scans through it. The study will save a pattern if it contains the query sequence; else, The study will filter it.

Definition 4.3: The study defines the current query item (qi) as the item that corresponds to the matching point in the query sequence in this study. Two flags are used to record the current position on the qi during the pattern growth. An itemset match position, abbreviated as IMatch, is the initial flag. The current location of the itemset that is matched to the query sequence can be recorded using IMatch. To find out where an item is in the itemset that is currently matching the query sequence, the study can use the second flag, which is IIMatch, which stands for item match position.There can determine that <(𝑏)> is the matching sequence and 𝑎 is qi, for instance, when there is a query sequence <(𝑏), (𝑎, 𝑑)> and a current pattern <(𝑏), (𝑏)>. Because of this, IMatch = 1 and IIMatch = 0.

Definition 4.4: Encoding a sequence 𝑦 as a bitmap returns [𝑆11 𝑆12..., 𝑆21...]. The study specifies the precise spot of the 𝑏-th itemset within the 𝑖-th sequence database as 𝑆𝑖𝑏. If 𝑏 and 𝑆𝑖 match, then 𝑆𝑖𝑏 is identical. A bitmap of the query sequence s = <(𝑎), (𝑏)> would be [0 0, 0 0 1 0, 0 0 1 0, 0 1 0 0]. As 𝑆2, 𝑆3, and 𝑆4 hold positions 2, 3, and 2, respectively, they can all match 𝑏. First, when does query sequence match? IMatch and IIMatch were begun at 0 in the research sequence. Every single iteration changes these two flags. Perfect matches are IMatch-length query sequences. After that, target sequential patterns can be preserved without modifying IMatch and IIMatch. II. When will IMatch and IIMatch updates arrive? The study compares an additional item of the current sequence to qi to assess if IMatch as well as IIMatch need updating. Both IIMatch and IMatch start at zero.

In this inquiry sequence, qi is the first item and the current sequencing is empty (<>). IMatch and IIMatch are set to 0 if long item 𝑏 does not match qi. Set IIMatch to 1 if qi matches item 𝑒. If it matches the query sequence's initial itemset, IMatch equals IIMatch + 1 and 0. The research compares query sequence qi to enlarged item qi as it progresses. If extended elements 𝑒 and qi are equivalent, update IIMatch to IIMatch + 1. If the query sequence's IMatch-th item equals IIMatch after the update, IMatch becomes IMatch + 1 and IIMatch 0. IIMatch needs updates for another reason. To revert to the matching position, set IIMatch to 0 during 𝑆-Extension. If the new article matches article qi, set IIMatch to 1 and check if IMatch and IIMatch need revisions after shifting the query sequence. If the extended item 𝑒 is less than qi, the research fails to update IMatch and IIMatch for the 𝐎-Extension sequence. Use the judgment technique to update IIMatch for identical qi or extended item 𝑏. If 𝑏 exceeds qi, set IIMatch to 0. Items are alphabetized in an itemset. Although 𝑽-Extension cannot identify a match for the itemset at position IMatch in the request sequence, the sequence continues. Consider the present sequence <(𝑎), (𝑏)> and the query sequence <(𝑎, 𝑏, 𝑐), (𝑒)>.

To continue 𝐼-Extension, add 𝑐 to the sequence <(𝑎), (𝑏, 𝑐)>. IIMatch and IMatch were adjusted because the expanded item matches the desired item. IIMatch updates automatically if research continues using 𝐎-Extension and item 𝑒. Mismatched location. The explanation is that lists <(𝑎), (𝑏, 𝑐, 𝑒)> and <(𝑎), (𝑏, 𝑐), (𝑒)> vary Former cannot match question a sequence, unlike latter. To fix this, NotUpdate checks IMatch and IIMatch for unupdates. The study won't modify IMatch and IIMatch if NotUpdate is true. By setting NotUpdate to accurate, the growth sequence may run 𝑎-Extension after IMatch modification. After 𝑆-Extension, the NotUpdate argument is set to false. This study will not modify IMatch or IIMatch: IMatch matches the query sequence and matches its size. Start with UTFP, or unpromising transactions filter pruning. NQS transactions are filtered by Database D. Transaction records without qs cannot form sequential patterns.

To save memory and boost efficiency, SPTA deletes irrelevant records for transactions. Mining frequent target sequence patterns is impossible if database D is below minsup before filtering.The study can present the query sequence qs' as a bitmap in [0 0, 0 0 0 1, 0 0 0 0, 0 0 0 1 The research must filter sequences 𝑏1 and 𝑏3 to lower length to [0 0 0 1, 0 0 0 1]. For sequences <(𝑔)> and minsup = 2, support rises to 3 until the uncertain transaction filters pruning method (UTFP) filters them. A maximum support of 1 for the required sequential pattern with 𝑏 leads to more errors. After filtering, Database D contains just 4 entries with the query pattern <(𝑎), (𝑒), (𝑓)>. No frequent target sequence patterns arise if |D| < minsup.Second Method (UPIP, Unpromising Prefix Item Trimming). The bulk of sequential pattern mining algorithms involve recursive growth with shared elements. A study determined the number of sequences with qi after a frequent item 𝑒 through contrasting the bitmaps of 𝑒 and q for a prefix item 𝑒. Researchers write fn. Queries start with qi again. The study does not employ 𝑒 to sustain development when fn is ≤ minsup and qi is absent.

Avoid starting patterns with 𝑏 as there is less support than minsup for any target sequence pattern. There, Study's query sequence qs' = <(𝑎), (𝑏)> has an appropriate minimum value of 2. Since sup(𝑓) = 2 ≥ minsup, it is likely frequent. Comparing UPIP-bitmaps. The query sequence qs' has a qi value of 𝑎 and a bitmap of [0 1 0 0, 1 0 0 0]. Use bitmap [0 0 0 1, 0 0 0 0, 0 0 0 1] for frequent item 𝑓. Of course, UIUP needs zero fn. Stop patterning with the shared object. Indeed, 𝑎 can be used successively, as in <(𝑎), (𝑏), (𝑓)> and sup(<(𝑎), (𝑏), (𝑓)> Plan 3 is the USIP (Disappointing 𝑆-Extension item reduction strategy). The study suggests using USIP to identify sequential patterns for recurrent increase after 𝑆-Extension. After comparing bitmaps, the study identifies sequences where qi follows expanded item 𝑒. Number notation is fn. The study fails to employ 𝑒 as an extended item to improve pattern if fn is below minsup. Thus, using the extended sequential pattern as a prefix is unable to target sequential pattern compatibility above minsup.

The function returns a count of sequences where qi is either equal to or following e if the extended item 𝑒 matches qi. Minsup = 2, currentsequence 𝑦 = <(𝑔)>, and request sequence qs' = <(𝑎), (𝑏)>. Prolonged sequence 𝑠′ = <(𝑏), (𝑏)> is a common pattern, and 𝑆-Extension may expand item 𝑏. Either 𝑎 and qi are important. Bitmaps display 𝑏′ as [0 1 1 0, 0 1 1 0, 0 0 0 0] and qi as [0 1 0 0, 0 1 1 0, 1 0 0 0]. Thus, fn= 1 and 𝑏′ do not apply to the development pattern. The query sequence qs' will have a different sequential pattern if 𝑏′ is extended. For extended item 𝑎, 𝑦′ bitmap is [0 1 0 0, 0 1 1 0, 0 0 0 0]. and fn = 2 ≥ minsup. <(𝑏), (𝑎)> can sustain growth. The desired sequence of query sequences qs' is <<(𝑏), (𝑎), (𝑏)>. Planning 4-UIIP (Unpromising U-Extension item trimming). USIP effectively generates patterns for single-item datasets using 𝑆-Extension. Multiple-element datasets can use 𝐼-Extension, reducing duplicate processes with UIIP. We offer UIIP to identify repeating patterns in 𝐽-Extension.

As in Question 2, we can omit updating IMatch and IIMatch if the expanded item is smaller than qi. If failing, research must rewrite IIMatch and IMatch. Changes in qi and match position. This study must consider two extended item possibilities. At first, qi and 𝑏 are considered equal. Count qi > e sequences with fn. A second case arises when 𝑒 surpasses qi, resulting in IIMatch set to 0. The total amount of sequences with qi greater than e is calculated using fn. The study advises against using item 𝑒 as an extended item when fn is smaller than minsup, wherein qs’ is a query sequence and 𝑒 is a current sequence with minsup = 2. It is clear that 𝐼-Extension can expand 𝑏, 𝑐, and 𝑑. Qi is more significant than 𝑏, which will remain intact. Longer sequence 𝑏′ bitmap is [0 1 0 0, 0 1 0 0], while qi bitmap is [...]. With fn set to 2, the pattern 𝑦′ = <(𝑏), (𝑎, 𝑏)> can go on indefinitely. When item 𝑐 matches, Qi changes to 𝑏. The bitmap of qi is [0 0 1 0, 0 0 1 0]. Prolonged sequence bitmap: [0 1 0 0]. Growth can keep going indefinitely for fn=2 and 𝑏′. If the final item 𝑑 exceeds qi, qi becomes 𝑎. Qi and the expanded sequence 𝑦′ have [0 1 0 0, 0 1 0 0] bitmaps. I shall not use 𝑏′ to create the pattern fn = 1.

b. Proposed SPTA Algorithm

To find patterns in massive datasets, the SPTA algorithm uses a systematic approach. Enter data, filter the database, generate items that appear often, and then prune prefix patterns. Gathering the sequence databases (D), the query sequences (qs’), and the minimum support thresholds are the three inputs needed for the input stage. To speed up mining, the database filtering stage employs the UTFP strategy, which stands for Unpromising Transaction Filter Pruning. In order to construct patterns, the frequent item creation stage produces frequent items. In order to maximize efficiency, the prefix pattern pruning (UPIP) method eliminates unproductive prefix patterns.

In figure 1 show that the S-extension pruning (USIP) and I-extension pruning (UIIP) techniques are important to the SPTA algorithm and help to enhance performance. Then, patterns are discovered by utilizing the pattern growth with S-extension and I-extension. The outcome is the target sequence patterns that were mined.

Input:

The first step of the process, where the algorithm is fed three parameters: the minimal support threshold, the query sequence (qs’), and the sequence databases (D). Finding patterns in data is the job of the sequence databases. The algorithm's search pattern or sequence in the databases is called the query sequences. A parameter called the minimum support threshold establishes the bare minimum of occurrences required for a pattern to be deemed statistically significant. The pattern mining process cannot begin without these inputs.

UTFP Strategy for Database Filtering:

This section applies UTFP, or Unpromising Transaction Filter Pruning, to the database. This method isolates the transactions that are pertinent to the query sequence by removing all others from the database. This improves the efficiency of the mining process by cutting down on superfluous computation.

Generating Items Regularly:

Scan the filtered database to generate frequent items after filtering the database. What we call "frequent items" are those that show up in the dataset quite often. Finding common items is essential because they provide a foundation for discovering patterns in the collection.

UPIP Strategy for Prefix Pattern Pruning:

This section applies the UPIP (Unpromising Prefix Item Pruning) method. By using this approach, the study wants to weed out prefix patterns that don't have much promise. The technique improves performance by decreasing the amount of needless operations during pattern mining and eliminating unproductive patterns.

SPTA Algorithm:

Several sub-components make up the basic SPTA algorithm, which is represented by this block: S-Extension Pruning (USIP Strategy): In order to enhance performance, this phase entails removing unproductive S-extension items. Things that can be appended to the very end of a sequence are called S-extension items. Here, in order to improve efficiency, unproductive I-extension items are removed. UIIP Strategy: One type of item is the insertion-extension item, which can be used in a sequence. Based on the query sequence and lowest support threshold, the algorithm systematically analyzes the dataset to uncover sequential patterns using S-Extension and I-Extension, a method for pattern growth. It expands patterns by extending them with S-or I-extensions.

Output of the Target Sequence:

This block stands for the algorithm's output step, when the ultimate result is printed out, containing the mined target sequence patterns. These recurring themes indicate significant sequences in the dataset that are a good fit for the query sequence and have enough support to be considered. The SPTA technique is shown in a structured overview by the block diagram, which highlights its main components and the flow of operations from input to output. In this way, we can see how the algorithm effectively finds decided on sequential patterns in massive datasets; each block stands for a different step in the process.

		𝑨𝒍𝒈𝒐𝒓𝒊𝒕𝒉𝒎 𝟏: SPTA Algorithm 
		𝑰𝒏𝒑𝒖𝒕: Sequence database (D). 
		qs’1: user-provided query sequence; minsup1: user-defined minimum support.
		Output: Every targeting sequential patterns of query sequence qs1. 
		Step 1: filters D sequences without qs (UTFP Strategy) 
		Step 2: the D is scanned again to identify frequent items (F1), 
 				eliminate infrequent items, construct a bitmap for frequent items, CMAP. 
		Step 3: Initialize qi is the first items in qs, IMatch is 0, IIMatch is 0; 
		Step 4: for frequent items <𝑓> in F1 do
              	initialize fn1 based on the comparison of 𝑓 and qi bitmaps. 
                if fn1 < minsup1 then 
                     continue (UPIP Strategy) 
 	         	end
 	         	UpdateMatch1(IMatch1, IIMatch1); 
                    Use SEARCH(<𝑓>, F1, {𝑒 ∈ F1 | 𝑒 ≻𝑙𝑒𝑥 𝑓 }, qs1, minsup1, IMatch1, IIMatch1 
             	end 
				

In algorithm 1, Searching a sequence database for sequential patterns that match a user-supplied query sequence and fulfill a user-defined minimum support threshold is made efficient with the Sequential Pattern Targeting Algorithm (SPTA). Several steps make up the algorithm: input, filtering out sequences that do not contain the query sequences, finding common items, setting variables to starting values, iterating over common things, and finally, running the SEARCH process. A user-supplied query sequences (qs1) and a minimum support threshold (minsup) are input into a sequence database (D). To improve efficiency, the UTFP method eliminates sequences that do not include the query sequences. A Conditional Maximum Pattern is formed by identifying frequently used items and creating a bitmap for each of them. The algorithm iteratively processes frequent items using the bitmap of 𝑓 and qi, and variables are initialized for future processing. Using the UPIP technique, the algorithm iterates further if fn1 is below the minimal support level. In response to a user-supplied query sequence, the algorithm returns all target sequential patterns satisfying the minimal support criterion.

		𝑨𝒍𝒈𝒐𝒓𝒊𝒕𝒉𝒎 2: Search procedure
		𝑰𝒏𝒑𝒖𝒕:
			𝑠1: the current sequence; 
		SE1: a set containing all items can perform 𝑆-Extension; 
			IE1: a set containing all items can perform 𝐼-Extension; 
			qs1: a query sequence provided by the user; 
			minsup1: a minimum support defined by the user; 
			IMatch1: the matching position of the itemset of the query sequence; 
			IIMatch1: the matching position of the item in the matching itemset of the query sequence.
		1. if IMatch1 == qs1.size1() then
		2. output 𝑠1;
		3. end
		4. initialize 𝑆𝑡𝑒𝑚𝑝 ← ∅, 𝐼𝑡𝑒𝑚𝑝 ← ∅;
		5. initialize newIMatch1 ← IMatch1, newIIMatch1 ← IIMatch1;
		6. initialize qi ← ∅, 𝑠′ ← <>, fn:=0;
		7. for each 𝑓 ∈ SE do
		8.  	 if CMAP1(s, 𝑓) < minsup1 then
		9.    		 continue; 
		10.  	end
		11.		  𝑠′ = 𝑠 extends 𝑓 by 𝑆-Extension;
		12. 	 if sup1(𝑠′) ≥ minsup1 then
		13.  		 𝑆𝑡𝑒𝑚𝑝 = 𝑆𝑡𝑒𝑚𝑝 ∪ 𝑓 
		14. 	 end
		15. end
		16. for each 𝑓 ∈ 𝑆𝑡𝑒𝑚𝑝 do
		17.   	𝑠′ = 𝑠 extend 𝑓 by 𝑆-Extension;
		18.  	newIMatch1, newIIMatch1 = call UpdateMatch1()
		19.  	fn1 = the outcome of associating the bitmaps of 𝑓 with the bitmaps of qi;
		20.	  if fn1< minsup1 then
		21.    		continue; 
		23.  	call SEARCH1(𝑠′, 𝑆𝑡𝑒𝑚𝑝, {𝑒 ∈ 𝑆𝑡𝑒𝑚𝑝 | 𝑒 ≻𝑙𝑒𝑥 𝑓 }, qs1, minsup1, newIMatch1, newIIMatch1)
		24. end
		25. for each 𝑓 ∈ IE do
		26.  	 if CMAP1(s, 𝑓) < minsup1 then
		27.     		continue; 
		28. 	  end
		29.  	 	𝑠′ = 𝑠 extends 𝑓 by 𝐼-Extension;
		30. 	  if sup(𝑠′) ≥ minsup1 then
		31.  		𝐼𝑡𝑒𝑚𝑝 = 𝐼𝑡𝑒𝑚𝑝 ∪ 𝑓
		32.   	 end
		33. end
		34. for each 𝑓 ∈ 𝐼𝑡𝑒𝑚𝑝 do
		35.  	 𝑠′ = 𝑠 extend 𝑓 by 𝐼-Extension;
		36.   	newIMatch1, newIIMatch1 = call UpdateMatch1();
		37.        fn1 = the outcome of associating the bitmaps of 𝑓 with the bitmaps of qi
		38.  		 if fn1 < minsup1 then
		39.     			continue; 
		40.	              end
		41.  	 call SEARCH(𝑠′, 𝑆𝑡𝑒𝑚𝑝, {𝑒 ∈ 𝐼𝑡𝑒𝑚𝑝 | 𝑒 ≻𝑙𝑒𝑥 𝑓 }, qs, minsup, newIMatch, newIIMatch)
		42. end							   
		

Algorithm 2's Search method is an integral aspect of the SPTA, or Sequential Pattern Targeting Algorithm. It recursively searches for patterns that match the user-provided query sequence (qs’) and fulfill the user-defined minimum support threshold (minsup1), and it also extends the current sequence with new items to investigate sequential patterns inside it. This process requires a number of input parameters, such as the current sequence (𝑦1), items that can execute 𝑆-Extension (SE1), items that can execute 𝐼-Extension (IE1), the user-supplied query sequence (qs1), and the minimum support threshold (minsup1). It is printed out if the size of the current sequence is equal to the corresponding position of the item sets of the query sequences. For every item in the set SE1, the procedure uses the UpdateMatch function to update corresponding positions, initializes variables for subsequent processing, and then repeats the process for items in the set 𝐽-Extension. It also extends the sequence with S-Extension (𝑆-Extension). This optimizes performance by methodically exploring sequential patterns.