Abstract:
Embodiments provide a method and system of text independent speaker recognition with a complexity comparable to a text dependent version. The scheme exploits the fact that speech is a quasi-stationary signal and simplifies the recognition process based on this theory. The modeling allows the speaker profile to be updated progressively with the new speech sample that is acquired during usage time.

Description:
PRIORITY CLAIM 
       [0001]    This application claims priority to provisional patent application No. 61/749,094, filed 4 Jan. 2013, which is incorporated herein by reference. 
     
    
     TECHNICAL FIELD 
       [0002]    The present disclosure relates generally to speech recognition systems, and more specifically to time scalable text independent speech recognition with automatic learning features. 
       BACKGROUND 
       [0003]    Speaker recognition is a biometric modality that uses a person&#39;s voice for identification purposes [1]. It is different from speech recognition where transcription of the spoken word is desired instead of the identity of the speaker. Before the system can be used, it must go through a training procedure where speech sample from the user are introduced to the system to build its speaker model. In the testing phase, the user speech is compared to the speaker model database and the one which closely resembles it is identified. 
         [0004]    There are two main types of speaker recognition. 
         [0005]    Text dependent speaker recognition 
         [0006]    In this mode, the user needs to utter specific keyword or phrase to be accepted by the system. It can either be password or a prompted phrase. The application here has a strong control over user input and it needs user cooperation to perform the identification process. 
         [0007]    Most text dependent speaker recognition system uses Hidden Markov Model (HMM) which provides statistical representation of the individual speech.  FIG. 1  shows the structure of HMM. The training process requires the user to say the phrase numerous time to build the statistical model. 
         [0008]    Another method is to use template matching where a sequence of feature vectors is build from the fixed phrase. The verification can be done by using Dynamic Time Warping (DTW) to measure the similarity between the test phrase and the template [2]. 
         [0009]    Text independent speaker recognition 
         [0010]    This working mode allows the user to say anything he or she wants, and the system should be able to perform the identification. Sufficient speech samples are needed in order to make the accurate recognition and the system has no knowledge of what is being spoken. The advantage is that the process can be done without the user cooperation. Various forms of neural network can be trained to perform this task, but the de facto reference method is the Gaussian Mixture Model (GMM) to represent the speaker model. Usually this GMM are adapted from a Universal Background Model (UBM) using adaptation method such as maximum a posteriori (MAP). In the recent years, Support Vector Machine (SVM) has been found to be the most robust classifier in speaker verification, and its combination with GMM has successfully increased the accuracy of the system. Please refer to [3] for a more complete overview of text independent speaker recognition. The National Institute of Standards and Technology periodically held a Speaker Recognition Evaluation to address various research problems and gauge the technology development related to this field. 
         [0011]    There is a need for improved methods and circuits for voice recognition in lower power applications such as in battery powered devices like smartphones. 
       SUMMARY 
       [0012]    Text dependent system has a lesser complexity than text independent version because of the system knowledge of the phrase that was going to be used for identification. However, text independent is more desired due its flexibility and unobtrusiveness. Many methods have been proposed to reduce the complexity of this system for example by using pre-quantization or speaker pruning [5]. This invention seeks to address the complexity issue of text independent speaker recognition by imitating the concept of text dependent version. 
         [0013]      FIG. 2  shows the training process of text dependent speaker recognition. Multiple utterance of the keyword or phrase is needed to build the reliable Markov Chain. For illustration purpose, in  FIG. 2 , the keyword “apple” is represented by 3 states model. The training process search for the transition probability between states (a11, a12 etc.) and the states statistics itself. Each state is usually represented by either a single Gaussian with full co-variance matrix, or a Gaussian Mixture with diagonal covariance matrix. In  FIG. 2 , b1 to b3 represents the Gaussian Mixture parameters, which consist of means, variance and the mixture weight. The training process to find these parameters is beyond the scope of this document, but the final results should maximise the likelihood of the trained word being generated by the model. 
         [0014]    In this invention, we try to build a text independent speaker recognition using the same structure as text de-pendent HMM. Unfortunately in this case, we do not have the user cooperation during testing so the user can say any word. It is also impossible to train the Markov chain discussed earlier because there is no transcribed speech to train it. This invention solves this problem by modelling a user speech into a smaller unit. This is the same modelling strategy used in [6]. A user speech is clustered, without the need of transcription, into 64 distinct units that represent the acoustic space of the speaker, or in other words, the speaker model. Each of this state can be thought of as one state of the Markov chain, even though there is no knowledge on what word it would represent. The second problem is to construct the transition probability between states. It is impossible to find the transition probability without the context of the word or phrase being modelled. This invention solves this by exploiting the fact that speech is a quasi-stationary signal. Following this, the transition probability of a state to itself is set to be higher than for a state to other states. These numbers are uniform for all the states in the speaker model.  FIG. 3  illustrates a subset of this speaker model. Contrary to  FIG. 2 , there is no association of each cluster with a particular sound or phoneme. 
         [0015]    Text dependent systems rely on the user saying the predetermined phrase or prompted phrase to decide the identity of the speaker. This system has prior knowledge on how the user would say that particular phrase, and this knowledge is generally captured using hidden Markov model. Text independent speaker recognition on the other hand collects samples of user&#39;s voice, in which the user can say anything he or she wants. The system will then built a profile from those collected speech and compare them to the list of pro-file available in its database. This task is more computationally intensive as the system is required to process significantly more speech samples compared to the text dependent counterpart. However, the advantage of text independent version is that recognition can be done without the user&#39;s cooperation and in a very discreet manner. This embodiment provides a new method of text independent speaker recognition with a complexity comparable to a text dependent version. The scheme exploits the fact that speech is a quasi-stationary signal and simplifies the recognition process based on this theory. The modeling allows the speaker profile to be updated progressively with the new speech sample that is acquired during usage time. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0016]      FIG. 1  shows the structure of a Hidden Markov Model. 
           [0017]      FIG. 2  shows the training process of text dependent speaker recognition where multiple utterance of the word “apple” is needed to construct the statistics of the Hidden Markov Model. 
           [0018]      FIG. 3  shows a subset of this speaker model used in this embodiment, showing only 4 clusters. 
           [0019]      FIG. 4  shows the block diagram of the process to build speaker profile. 
           [0020]      FIG. 5  shows an example of the template path for text dependent version. 
           [0021]      FIG. 6  shows the best path probability (highest loglk value) for each speaker. 
           [0022]      FIG. 7  shows the working of the embodiment where the path of a speaker will be closer to GMM mean that that of a non speaker, resulting in a higher log likelihood value. . 
           [0023]      FIG. 8  shows the block diagram to extract MFCC which is the features used in this embodiment. 
           [0024]      FIG. 9  shows the triangular filter used on the PSD during MFCC extraction to obtain each Mel frequency bin value. 
           [0025]      FIG. 10  shows the decoding process per audio frame that has to be calculated per speaker model. 
       
    
    
     DETAILED DESCRIPTION 
       [0026]    The embodiment provides a new method to reduce the complexity of text independent speaker recognition system by reusing the structure of text dependent version. Instead of comparing the input speech with a template path, only the probability of each cluster is calculated. The transition probability is substituted with two constant to represent transition to the same cluster and to different cluster. With this embodiment, only the log likelihood (loglk) variable per cluster needs to be stored at each iteration, that is whenever new frame of speech is received. No other information needs to be retained for future processing, which results in memory savings. Contrary to conventional methods of text independent speaker recognition which requires enough speech sample before the system is able to make the decision, this embodiment enables the system to make the decision at any point in time by looking at the current loglk value. The confidence of the result can be set proportional to the difference in likelihood between the winning speaker and the next highest result. When confidence is high, the speech is automatically used to improve the speaker profile by performing further training process. 
         [0027]    In the following description, certain details are set forth in conjunction with the described embodiments to provide a sufficient understanding of the embodiment. One skilled in the art will appreciate, however, that the embodiment may be practiced without these particular details. Furthermore, one skilled in the art will appreciate that the example embodiments described below do not limit the scope of the present disclosure, and will also understand that various modifications, equivalents, and combinations of the disclosed embodiments and components of such embodiments are within the scope of the present disclosure. Embodiments including fewer than all the components of any of the respective described embodiments may also be within the scope of the present disclosure although not expressly described in detail below. Finally, the operation of well-known components and/or processes has not been shown or described in detail below to avoid unnecessarily obscuring the present embodiment. 
         [0028]    This embodiment can be combined with various front end speech processing as it is independent of the features used for the recognition process. In this section, it will be demonstrated how this will work with a simple front end using MFCC as features. 
         [0029]    The training part of this innovation consists of building the acoustic space of the speaker model.  FIG. 4  illustrates this process. The speech data are processed per frame, and the Mel Frequency Cepstral Coefficients (MFCC) are extracted. These MFCC coefficients are then clustered into 64 groups depending on its Euclidian distance. Any clustering methods can be applied for this purpose, one of which is the K-means clustering method. Each of these clusters is then modelled using Gaussian Mixture, and the results constitute the speaker profile. This profile is built for each of the registered speaker. 
         [0030]    During usage time, a speech from unknown speaker is received and the system will choose which of the profile that speech most likely belongs to. This invention will test each of the speaker profile and find the probability through these steps (note that this processing is done per frame) 
         [0031]    The MFCC of the speech signals is extracted 
         [0032]    The probability of that frame belonging to each of the clusters are calculated 
         [0033]    The final probability is calculated by taking into account the transition from the previous cluster. 
         [0034]    Repeat the process for the next frame. 
         [0035]    This process is similar to text dependent speaker recognition, but since there is no fixed word or phrase for the recognition, the template path sequence between clusters does not exist.  FIG. 5  shows an example of the template path for text dependent version. This path represents certain words being said, and for text dependent version, this path will be compared with the speech from unknown speaker. In this innovation, the text independent speaker recognition does not compare it to any path, but only generating the best sequence which results in the highest probability value. There is one issue that must be dealt with, that is the transition probability. The transition probability of a template path is generated from multiple utterance of the same word, which was not available for text independent version. This innovation relies on only two transition probability value: the transition to itself, and transition to other cluster. Since speech is a quasi stationary signal, the value of the former is much higher than the later. The following pseudo code explains the steps in deriving the final probability value: 
         [0000]    
       
         
               
             
               
               
             
               
               
             
               
             
               
               
             
               
               
             
               
             
               
               
             
               
               
             
               
               
             
               
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
             
               
               
             
               
               
             
               
             
           
               
                   
               
             
             
               
                 /*----Initialisation----*/ 
               
               
                 T = number of frames of test speech sample; 
               
               
                 for(i=0;i&lt;T;i++) 
               
             
          
           
               
                   
                 for(j=0;j&lt;Number_of_cluster ;j++) 
               
             
          
           
               
                   
                  loglk[i]G]=−1000000000000000000.0; 
               
             
          
           
               
                 for(i=0;i&lt;Number_of_cluster;i++) 
               
               
                 { 
               
             
          
           
               
                   
                  likelihood = GMM_likelihood( input, i, 0, speaker); 
               
             
          
           
               
                   
                  loglk[0][i]=logx(likelihood); 
               
             
          
           
               
                 } 
               
               
                 /*----Recursion-----*/ 
               
               
                 for(t=1;t&lt;T;t++) 
               
               
                  { 
               
             
          
           
               
                   
                 for(j=0;j&lt; Number_of_cluster;j++) 
               
               
                   
                  { 
               
             
          
           
               
                   
                 Initialize maximum_value to a very small number; 
               
               
                   
                 for(i=0;i&lt; Number_of_cluster;i++) 
               
               
                   
                  { 
               
             
          
           
               
                   
                 if(i!=j) //moving from cluster i to cluster j 
               
               
                   
                  value = loglk[t−1][i]+logx_transition; 
               
             
          
           
               
                   
                 else 
                 //remain in same cluster 
               
             
          
           
               
                   
                  value = loglk[t−1][i]+logx_selfTransition; 
               
               
                   
                 if(value &gt; maximum_value) 
               
             
          
           
               
                   
                 maximum_value=value; 
               
             
          
           
               
                   
                  } 
               
             
          
           
               
                   
                  likelihood = GMM_likelihood( input, j, t, speaker ); 
               
             
          
           
               
                   
                 loglk[t][j]=logx(likelihood) + maximum_value; 
               
             
          
           
               
                  } 
               
               
                 } 
               
               
                 /*-----Find highest loglikelihood-----*/ 
               
               
                 Result = −1000000000000000000.0; 
               
               
                 for(i=0;i&lt; Number_of_cluster;i++) 
               
               
                  { 
               
             
          
           
               
                   
                 If (loglk[T−1][i] &gt; Result) 
               
             
          
           
               
                   
                 Result = loglk[T−1][i]; 
               
             
          
           
               
                  } 
               
               
                   
               
             
          
         
       
     
         [0036]    The function GMM_likelihood(input, j, t, speaker) computes the probability of the “input” frame at time “t” belonging to the “speaker” cluster number “j”. This is calculated per Gaussian component by 
         [0000]    
       
         
           
             
               f 
                
               
                 ( 
                 
                   
                     x 
                     ; 
                     μ 
                   
                   , 
                   
                     σ 
                     2 
                   
                 
                 ) 
               
             
             = 
             
               
                 1 
                 
                   σ 
                    
                   
                     
                       2 
                        
                       π 
                     
                   
                 
               
                
               
                 e 
                 
                   - 
                   
                     
                       
                         ( 
                         
                           x 
                           - 
                           μ 
                         
                         ) 
                       
                       2 
                     
                     
                       2 
                        
                       
                         σ 
                         2 
                       
                     
                   
                 
               
             
           
         
       
     
         [0037]    where x is the input signal (in this case, the MFCC of the input signal), μ and σ2 are the mean and variance of the Gaussian distribution. The results per component are finally combined as: 
         [0000]    
       
         
           
             GMM_likelihood 
             = 
             
               
                 ∑ 
                 
                   m 
                   = 
                   0 
                 
                 
                   M 
                   - 
                   1 
                 
               
                
               
                 
                   w 
                   m 
                 
                  
                 
                   f 
                    
                   
                     ( 
                     
                       x 
                       ; 
                       
                         
                           μ 
                           m 
                         
                          
                         
                           σ 
                           m 
                           2 
                         
                       
                     
                     ) 
                   
                 
               
             
           
         
       
     
         [0038]    where M is the number of mixtures and wm is the mixture weight. 
         [0039]    The simplification in this method came from the two variable “logx_transition” and “logx_selfTransition” which contains the log likelihood of the transition to different state and to the same state respectively. In text dependent speaker recognition, these values are square matrixes representing the state transition probability derived during the training process with transcribed speech. Since we do not have that, the value used are logx(0.95) for self transition and logx(0.05) for the other one, emphasizing the point that it should be more likely to maintain its current state. 
         [0040]    The pseudo code above can be distinctively separated into initialization, processing, and ending state. This is an advantage for real time application as the initialization and the ending state only needs to be performed once, that is before and after the frame loop. The main loop (noted with the “recursion” comment) is what&#39;s being performed on each frame. It utilizes dynamic programming concept to find the highest probable state sequence. The variable “loglk[t][j]” holds the best probability value at time t, calculated from t=0, and ending at state j. In the actual implementation, only one dimensional variable loglk[j] is required since there was no need to keep the value for the time that has already passed. Each speaker will have their own loglk[j] variable and the speaker with the highest value is chosen as the output speaker. 
         [0041]    The more speech sample available, the more reliable the result is.  FIG. 6  shows the best path probability for each speaker. The x axis is the timeline in terms of frame. The decision of the winning speaker can be made at any point in time. The more it progresses, the more distinct the difference is between the speakers, and the confidence level is higher to choose the winning speaker. The difference between the best probability and the second can be made as security setting. For applications which is more tolerant to error, this threshold can be made small so the decision can be made quicker on who is the output speaker. For applications requiring reliability however, this threshold should be set higher such that only when the system is confidence enough with the output (difference with the second winning speaker is high), then the output speaker can be decided. A reset needs to be done after a period of time, and the most appropriate time to do it is after a sufficient period of silence (no speech) is observed. 
         [0042]      FIG. 7  illustrates the working of this scheme. The solid line path represents the speech of the correct speaker. It rest nearer to the black dot (representing the mean of the Gaussian distribution), and hence would results in higher probability value compared to the non speaker counterpart (the dashed line path). As mentioned before, the system does not care about what was being said so the path can be immediately deleted after the probability value is calculated. 
       Detail Description of Preferred Embodiments 
       [0043]    This invention can be combined with various front end speech processing as it is independent of the features used for the recognition process. 
         [0044]    In this section, it will be demonstrated how this will work with a simple front end using MFCC as features. 
         [0045]    Front End Processing 
         [0046]    The analysis of speech and speaker recognition task are not done on the speech signal itself, but on features derived from it. All incoming speech signal goes through this front end processing.  FIG. 8  shows the block diagram to extract MFCC which is the features used in this invention 
         [0047]    Preemphasis 
         [0048]    Preemphasis is done using the following equation 
         [0000]        S ( t )= S   in ( t )−0.96 S   in ( t− 1)
 
         [0049]    where Sin is the input signal and t is the time index. 
         [0050]    Framing 
         [0051]    Processing is done per frame, where each frame here is 320 sample in length and progressing by 160 sample to the next frame. In 16 khz sampling rate, this correspond to 20 ms frame progressing by 10 ms each. The Hamming window is applied on each frame, following the equation below 
         [0000]    
       
         
           
             
               w 
                
               
                 ( 
                 n 
                 ) 
               
             
             = 
             
               0.54 
               - 
               
                 0.46 
                  
                 
                   cos 
                    
                   
                     ( 
                     
                       
                         2 
                          
                         π 
                          
                         
                             
                         
                          
                         n 
                       
                       
                         N 
                         - 
                         1 
                       
                     
                     ) 
                   
                 
               
             
           
         
       
     
         [0052]    where N is the frame size (in this case  320 ) and n is the time index of this window. 
         [0053]    PSD 
         [0054]    Discrete Fourier Transform (DFT) is used to analyze the frequency content of the signal and the Power Spectral Density (PSD) is calculated as follows: 
         [0000]    
       
         
           
             
               PSD 
                
               
                 ( 
                 k 
                 ) 
               
             
             = 
             
               
                  
                 
                   
                     ∑ 
                     
                       t 
                       = 
                       0 
                     
                     
                       FFTlen 
                       - 
                       1 
                     
                   
                    
                   
                     
                       
                         S 
                         win 
                       
                        
                       
                         ( 
                         t 
                         ) 
                       
                     
                     . 
                     
                       e 
                       
                         
                           - 
                           jtk 
                         
                          
                         
                           
                             2 
                              
                             π 
                           
                           FFTlen 
                         
                       
                     
                   
                 
                  
               
               2 
             
           
         
       
     
         [0055]    MEL 
         [0056]    The MEL warping is approximated by 
         [0000]        mel ( f )=2595log 10 (1+ f/   700 ) 
         [0057]    Triangular filter is used on the PSD as shown in  FIG. 9 . The output is calculated as 
         [0000]    
       
         
           
             
               Mel 
                
               
                 ( 
                 i 
                 ) 
               
             
             = 
             
               
                 ∑ 
                 
                   k 
                   = 
                   0 
                 
                 
                   FFTlen 
                   / 
                   2 
                 
               
                
               
                 
                   W 
                   
                     i 
                     , 
                     k 
                   
                 
                  
                 
                   PSD 
                    
                   
                     ( 
                     k 
                     ) 
                   
                 
               
             
           
         
       
     
         [0058]    where i is the Mel frequency bin, W is the weight of the triangular filter. 
         [0059]    Log and DCT 
         [0060]    The final step is to take the log and perform the Discrete Cosine Transform (DCT) to get the final MFCC output. 
         [0000]    
       
         
           
             
               MFCC 
                
               
                 ( 
                 j 
                 ) 
               
             
             = 
             
               
                 ∑ 
                 
                   i 
                   = 
                   1 
                 
                 Q 
               
                
               
                 log 
                  
                 
                   ( 
                   
                     
                       Mel 
                        
                       
                         ( 
                         i 
                         ) 
                       
                     
                      
                     
                       cos 
                        
                       
                         ( 
                         
                           
                             
                               j 
                                
                               
                                   
                               
                                
                               π 
                             
                             Q 
                           
                            
                           
                             ( 
                             
                               i 
                               - 
                               0.5 
                             
                             ) 
                           
                         
                         ) 
                       
                     
                   
                   ) 
                 
               
             
           
         
       
     
         [0061]    The rest of the analysis uses these MFCC values. In this invention, 24 MFCC were used. 
         [0062]    Training Process: Generating the Speaker Profile 
         [0063]    The speaker profile is a representation of the speaker acoustic space. In this invention, 64 cluster of Gaussian Mixture Model is used, made from user speech as depicted in  FIG. 4 . After going through the front end processing (step  1 ), the features are clustered using k-means algorithm as follows: 
         [0064]    Initialization 
         [0065]    64 vectors are randomly chosen as the initial centroids. 
         [0066]    Nearest Neighbour Search 
         [0067]    Each of the training vectors are grouped with the centroid that has the closest Euclidian distance to it. 
         [0068]    Centroid Update 
         [0069]    Within each centroid, a new mean is calculated taking accounts all the vectors that has been grouped with it. The new mean is set as the new centroid. 
         [0070]    Repeat step b and c until the distortion falls under a threshold. 
         [0071]    Each of the clusters is then represented by Gaussian Mixture Model. 
         [0072]    Testing/Decoding 
         [0073]      FIG. 10  illustrates the decoding process per audio frame that has to be calculated per speaker model. The speaker with the maximum output value is chosen to be output speaker. Note that with this scheme, only the variable Loglk is needed per speaker, as it represent the probability of the speech to end at the corresponding cluster. No information about the path sequence is needed. The output speaker can be decided at any point in time. 
         [0074]    Automatic Training 
         [0075]    When enough speech is obtained during the decoding process and the confidence level to choose a particular output speaker is above a predetermined threshold, the speech samples are used to perform further adaptation to the speaker profile, following the training process describes in step  2 . The only different is that the initial centroids are not random, but following the current cluster. 
       Effects of the Invention 
       [0076]    The invention provides a new method to reduce the complexity of text independent speaker recognition system by reusing the structure of text dependent version. Instead of comparing the input speech with a template path, only the probability of each cluster is calculated. The transition probability is substituted with two constant to represent transition to the same cluster and to different cluster. With this invention, only the log likelihood (loglk) variable per cluster needs to be stored at each iteration, that is whenever new frame of speech is received. No other information needs to be retained for future processing, which results in memory savings. Contrary to conventional methods of text independent speaker recognition which requires enough speech sample before the system is able to make the decision, this invention enables the system to make the decision at any point in time by looking at the current loglk value. The confidence of the result can be set proportional to the difference in likelihood between the winning speaker and the next highest result. When confidence is high, the speech is automatically used to improve the speaker profile by performing further training process. 
         [0077]      FIG. 11  is a functional block diagram of an electronic device  800  including speech-recognition circuitry  802  contained in processing circuitry  804  according to one embodiment of the present disclosure. The speech recognition circuitry  802  corresponds to circuitry and/or software that executes the speaker dependent voice recognition algorithms described above with reference to  FIGS. 1-7 . The processing circuitry  804  may be any suitable processing circuitry, such as a microprocessor where the electronic device  800  is a personal computer or an applications processor where the electronic device is a smartphone or tablet computer. Similarly, the touch controller  806  may include any suitable digital and/or analog circuitry to perform the desired functions of the controller. 
         [0078]    The electronic device  800  includes a touch controller  806  that detects the presence of touches or touch points P(X,Y) and gestures including such touch points on a touch screen  808  that is coupled to the controller. The touch screen  808  has a number of touch sensors  810  positioned on the touch screen to detect touch points P(X,Y), with only three touch sensors being shown merely to simplify the figure. The touch controller  806  controls the touch screen  808  to detect a user&#39;s finger, stylus, or any other suitable device, all of which will collectively be referred to as a “user device” herein. The detection of the user device at a particular location on the touch screen  808  is defined as a touch point P(X,Y) on the touch screen. An X-axis and Y-axis are shown in  FIG. 1 , with the X coordinate of a touch point P(X,Y) corresponding to a point along the X-axis and the Y coordinate to a point along the Y-axis. The touch sensors  810  generate corresponding sensor signals responsive to a touch point P(X,Y) and provide these signals to the touch controller  808  for processing. The touch sensors  810  are typically contained in some sort of transparent sensor array that is part of the touch screen  808 , the detailed structure of which is understood by those skilled in the art and thus will not be described herein. The number and location of the touch sensors  810  can vary as can the particular type of sensor, such as ultrasonic, resistive, vibration, or capacitive sensors. 
         [0079]    The processing circuitry  804  is coupled to the touch controller  102  and is operable to execute applications or “apps”  812  designed to perform a specific function or provide a specific service on the electronic device  800 . Where the electronic device  800  is a cellular phone or a tablet computer, for example, the applications  812  can include a wide variety of different types of applications, such as music applications, email applications, video applications, game applications, weather applications, reader applications, and so on. The touch controller  806  reports touch information to the applications  812 , which operate in response thereto to control operation of the application and/or the electronic device  800 . 
         [0080]    The electronic device  800  can be any kind of suitable electronic device or system. The device  800  need not include the touch screen  808  and can include additional components not expressly illustrated in  FIG. 8 . For example, the electronic device  800  could be a personal computer system, desktop or laptop, a television, a home-theater system, a smart appliance, a vehicle such as a car or truck where the algorithm is used in lieu of a key to access, activate, and deactivate the vehicle, a security system that provides or denies the speaker access to a facility, and so on. 
         [0081]    In one embodiment, the electronic device  800  operates in a sleep or low-power mode of operation and the speaker dependent voice recognition algorithm executes during this mode to detect the utterance of the code phrase by an authorized user or users. The low-power mode is a mode of operation that is common in electronic devices in which at least some of the electronic components in the device are powered down or placed in an alternate state to reduce the power consumption of these components and thereby reduce the overall power consumption of the electronic device. In response to detecting the code phrase, the electronic device  800  is then “activated” or leaves the low-power mode of operation. For example, where the device  800  is a smart phone, when the algorithm detects the utterance of the code phrase by an authorized user the home screen or some other screen is then displayed to give the speaker access to and allow him or her to operate the device. 
         [0082]    One skilled in the art will understood that even though various embodiments and advantages have been set forth in the foregoing description, the above disclosure is illustrative only, and changes may be made in detail, and yet remain within the broad principles of the embodiment. For example, some of the components described above may be implemented using either digital or analog circuitry, or a combination of both, and also, where appropriate, may be realized through software executing on suitable processing circuitry. The code phrase may be in any language, not just English, and could even be gibberish or a random sequence of sounds or a sound desired defined by the user. Therefore, the present disclosure is to be limited only as defined by the appended claims and any such later-introduced claims supported by the present disclosure.