Xf1dZddlZddlmZejdeGddZGddeZGd d eZdS) zDynamic Programming algorithms for general usage. This module contains classes which implement Dynamic Programming algorithms that can be used generally. N)BiopythonDeprecationWarningzThe 'Bio.HMM.DynamicProgramming' module is deprecated and will be removed in a future release of Biopython. Consider using the hmmlearn package instead.c0eZdZdZdZdZdZdZdZdS)AbstractDPAlgorithmsaAn abstract class to calculate forward and backward probabilities. This class should not be instantiated directly, but should be used through a derived class which implements proper scaling of variables. This class is just meant to encapsulate the basic forward and backward algorithms, and allow derived classes to deal with the problems of multiplying probabilities. Derived class of this must implement: - _forward_recursion -- Calculate the forward values in the recursion using some kind of technique for preventing underflow errors. - _backward_recursion -- Calculate the backward values in the recursion step using some technique to prevent underflow errors. c"||_||_dS)zInitialize to calculate forward and backward probabilities. Arguments: - markov_model -- The current Markov model we are working with. - sequence -- A training sequence containing a set of emissions. N)_mm_seqself markov_modelsequences :lib/python3.11/site-packages/Bio/HMM/DynamicProgramming.py__init__zAbstractDPAlgorithms.__init__-s  c td)z0Calculate the forward recursion value (PRIVATE).Subclasses must implementNotImplementedErrorr cur_state sequence_pos forward_varss r _forward_recursionz'AbstractDPAlgorithms._forward_recursion8!"=>>>rc|jj}i}d||ddf<tdt|D]}d|||df<tt|jjD]'}|D]"}||||}|||||f<#(|d}d}|D]B} || t|jjdz f}|jj| |f} ||| zz }C||fS)aCalculate sequence probability using the forward algorithm. This implements the forward algorithm, as described on p57-58 of Durbin et al. Returns: - A dictionary containing the forward variables. This has keys of the form (state letter, position in the training sequence), and values containing the calculated forward variable. - The calculated probability of the sequence. r)rstate_alphabetrangelenr emissionsrtransition_prob) r state_letters forward_varki main_state forward_value first_stateseq_prob state_itemtransition_values r forward_algorithmz&AbstractDPAlgorithms.forward_algorithm<sB/  ./ ]1%r*+q#m,,-- 4 4A23Kq)2. / / s49.//00 A AA+ A A !% 7 7 A{ S S  ,3@KQ0  A$A& ' 9 9J'S9L5M5MPQ5Q(RSM#x7[8QR   (88 8HHH$$rc td)z1Calculate the backward recursion value (PRIVATE).rrrs r _backward_recursionz(AbstractDPAlgorithms._backward_recursiontrrc|jj}i}|d}|D];}|jj||df||t|jjdz f< ? ?5TY%8!9!9A!=>>??  C CA+ C C "&!9!9*a!V!V!-4BL*a1  CrN) __name__ __module__ __qualname____doc__rrr,r.r7rr rrsj$   ???6%6%6%p???00000rrc*eZdZdZdZdZdZdZdS)ScaledDPAlgorithmsaImplement forward and backward algorithms using a rescaling approach. This scales the f and b variables, so that they remain within a manageable numerical interval during calculations. This approach is described in Durbin et al. on p 78. This approach is a little more straightforward then log transformation but may still give underflow errors for some types of models. In these cases, the LogDPAlgorithms class should be used. cLt|||i|_dS)aInitialize the scaled approach to calculating probabilities. Arguments: - markov_model -- The current Markov model we are working with. - sequence -- A TrainingSequence object that must have a set of emissions to work with. N)rr _s_valuesr s r rzScaledDPAlgorithms.__init__s' %%dL(CCCrc|jj}d}|D]v}|jj||jj|f}d}|j|D]+}|||dz f} |jj||f} || | zz },|||zz }w|S)aCalculate the next scaling variable for a sequence position (PRIVATE). This utilizes the approach of choosing s values such that the sum of all of the scaled f values is equal to 1. Arguments: - seq_pos -- The current position we are at in the sequence. - previous_vars -- All of the forward or backward variables calculated so far. Returns: - The calculated scaling variable for the sequence item. rr)rr emission_probrr transitions_fromr!) r seq_pos previous_varsr"s_valuer&emissiontrans_and_var_sum second_state var_value trans_values r _calculate_s_valuez%ScaledDPAlgorithms._calculate_s_values / ' 4 4Jx-TY09:H !"  $ 9 9* E E = = )<1*EF #h6 j7QR !Y%<<!! x"33 3GGrcf||jvr||||j|<|jj|}|jj||f}||j|z }d}d}|j|D]-} d}|| |dz f} |jj| |f} || | zz }.|r||zSdS)aDCalculate the value of the forward recursion (PRIVATE). Arguments: - cur_state -- The letter of the state we are calculating the forward variable for. - sequence_pos -- The position we are at in the training seq. - forward_vars -- The current set of forward variables rrN)r@rLrr rrBrCr!) r rrr seq_lettercur_emission_probscale_emission_prob state_pos_sumhave_transitionrI prev_forwardcur_trans_probs r rz%ScaledDPAlgorithms._forward_recursions t~ - -+/+B+Bl,,DN< ( Y(6  H2Iz3JK/$.2NN  H55i@@ ; ;LO(|a7G(HIL"X5|Y6OPN \N: :MM  &6 64rch||jvr||||j|<d}d}|j|D]Y}d}|jj|dz}|jj||f}|||dzf} |jj||f} ||| z| zz }Z|r||j|z SdS)aGCalculate the value of the backward recursion (PRIVATE). Arguments: - cur_state -- The letter of the state we are calculating the forward variable for. - sequence_pos -- The position we are at in the training seq. - backward_vars -- The current set of backward variables rrN)r@rLrrCrr rBr!) r rr backward_varsrQrRrIrNrO prev_backwardcur_transition_probs r r.z&ScaledDPAlgorithms._backward_recursions t~ - -+/+B+Bm,,DN< (   H55i@@ U ULO,\A-=>J $ 6 :7N O *<9I*JKM#'(":I|;T"U  .>ATT TMM   4>,#?? ?4rN)r8r9r:r;rrLrr.r<rr r>r>s\     &&&P***X)))))rr>ceZdZdZdZdS)LogDPAlgorithmszImplement forward and backward algorithms using a log approach. This uses the approach of calculating the sum of log probabilities using a lookup table for common values. XXX This is not implemented yet! c td)zInitialize the class.zHaven't coded this yet...rr s r rzLogDPAlgorithms.__init__MrrN)r8r9r:r;rr<rr rZrZDs-?????rrZ)r;warningsBiorwarnrr>rZr<rr r_s ++++++    NNNNNNNNbVVVVV-VVVr ? ? ? ? ?* ? ? ? ? ?r