{smcl} {cmd:help mimpt} {hline} {title:Title} {p 4 8 2} {cmd:mimpt} {hline 2} Impute missing values, persist in case of non-convergence {title:Syntax} {p 8 16 2} {cmd:mimpt} {it:{help mi_impute:...}} {cmd:,} {opt add(#)} {opt skipnonconvergence(#)} [ {it:options} ] {p 4 10 2} where {it:{help mi_impute:...}} is the standard {helpb mi impute} syntax {synoptset 24 tabbed}{...} {synopthdr} {synoptline} {p2coldent:* {cmd:add(#)}}specify number of imputations to add; same as with {help mi_impute##impopts:mi impute} {p_end} {p2coldent:* {cmd:skipnonconvergence(#)}}specify how many non-convergence errors to ignore {p_end} {synopt:{opt blocksize(#)}}specify number of imputations to add at a time; default is {cmd:blocksize(1)} {p_end} {synopt:{help mi_impute##impopts:{it:impute_options}}}any options for {help mi impute} {p_end} {synoptline} {p2colreset}{...} {p 4 6 2}* {opt add(#)} is required{p_end}{...} {p 4 6 2}* {opt skipnonconvergence(#)} is required{p_end} {title:Description} {pstd} {cmd:mimpt} is a wrapper for {helpb mi impute} that does not stop if the imputation model fails to converge. Instead of stopping if the imputation model fails to converge, {cmd:mimpt} repeats the imputation process for the respective dataset. {pstd} The problem: Multiple imputations {help mi_impute_chained:via chained equations} often fails because one of the models, usually {help mlogit}, fails to converge. If this happens, Stata's {help mi impute} command will stop with the respective error message and return code {search r(430), local:r(430)}. Stata's {help mi impute} will also discard all imputations that have been added so far. {pstd} Non-convergence of the imputation model might indicate problems. If a model fails to converge early on during the imputation process or if a model fails to converge repeatedly, the model should be inspected and fixed. If, however, the model fails to converge in, say, iteration 7 on {it:m}=42, the respective model has successfully converged 416 times (assuming the default burin-in) before it failed once. Chances are, there is no systematic problem with that model; chances are, the model will converge again in iteration 8 on {it:m}=42. It is this situation for which {cmd:mimpt} is designed. Instead of stopping the imputation process altogether and discarding all 41 completed datasets, {cmd:mimpt} repeats the imputation process for {it:m}=42 (but see {help mimpt##blocksize:option {bf:blocksize()}}). {pstd} Disclaimer: I am not aware of any literature that discusses potential problems when (occasional) non-convergence is ignored during the imputation process. I believe that this approach is preferable to what is currently the only alternative: modify the respective model. Modifying the respective model will have a much larger impact on the imputations because the modifications affect every iteration in every imputed dataset. Ignoring occasional non-convergence appears to be much less invasive. {title:Options} {phang} {opt add(#)} is the same as with {help mi_impute##options:mi impute} and specifies the number of imputations to add. {phang} {opt skipnonconvergence(#)} is required and it specifies how many non-convergence errors are ignored. If the imputation model fails to converge more often than {it:#}, {cmd:mimpt} will stop with return code {search r(430), local:r(430)} and discard all imputed datasets. {marker blocksize}{...} {phang} {opt blocksize(#)} specifies the number of imputations to add at a time. This is a technical option that is best explained technically. Let {it:M} be the number of imputations specified in option {opt add(M)}, and let {it:s} be the number specified in option {opt blocksize(s)}. {cmd:mimpt} calls {help mi impute} {it:M}/{it:s} times. If a model fails to converge, {cmd:mimpt} repeats at least 1 at at most {it:s} imputations. For example, if we specify {cmd:add(10)} and {cmd:blocksize(5)}, and a model fails to converge on {it:m}=7, {cmd:mimpt} repeats the imputation process for {it:m}=6 and {it:m}=7. {p 8 8 2} {opt blocksize()} does not affect the number of imputed datasets, {it:M}. If the imputation model fails to converge at least once, different values of {opt blocksize()} are likely to produce different results. {title:Examples} {pstd} Generic {phang2}{cmd:. mimpt {it:...} mlogit {it:...} , add(100) skipnonconvergence(5)}{p_end} {title:Stored results} {pstd} {cmd:mimpt} does not save anything in {cmd:r()}. Results in {cmd:r()} are those of the last call to {help mi impute}. {title:Author} {pstd} Daniel Klein{break} University of Kassel{break} klein.daniel.81@gmail.com {title:Also see} {psee} Online: {helpb mi}, {helpb mi impute}{p_end} {psee} if installed: {helpb ice}{p_end}