LDA

java.lang.Object
- org.apache.spark.ml.PipelineStage
- - org.apache.spark.ml.Estimator<LDAModel>
  - - org.apache.spark.ml.clustering.LDA

All Implemented Interfaces:

java.io.Serializable, Params, Identifiable
```
public class LDA
extends Estimator<LDAModel>
```
:: Experimental ::
Latent Dirichlet Allocation (LDA), a topic model designed for text documents.
Terminology: - "term" = "word": an element of the vocabulary - "token": instance of a term appearing in a document - "topic": multinomial distribution over terms representing some concept - "document": one piece of text, corresponding to one row in the input data
Original LDA paper (journal version): Blei, Ng, and Jordan. "Latent Dirichlet Allocation." JMLR, 2003.
Input data (featuresCol): LDA is given a collection of documents as input data, via the featuresCol parameter. Each document is specified as a Vector of length vocabSize, where each entry is the count for the corresponding term (word) in the document. Feature transformers such as Tokenizer and CountVectorizer can be useful for converting text to word count vectors.

See Also:
http://en.wikipedia.org/wiki/Latent_Dirichlet_allocation Latent Dirichlet allocation (Wikipedia)}, Serialized Form

Constructor Summary

Constructors
Constructor and Description

LDA()

LDA(java.lang.String uid)

Constructors
Constructor and Description
`LDA()`
`LDA(java.lang.String uid)`

Method Summary

Methods
Modifier and Type	Method and Description
`protected static <T> T`	`$(Param<T> param)`
`static IntParam`	`checkpointInterval()`
`IntParam`	`checkpointInterval()` Param for set checkpoint interval (>= 1) or disable checkpoint (-1).
`static Params`	`clear(Param<?> param)`
`LDA`	`copy(ParamMap extra)` Creates a copy of this instance with the same UID and some extra params.
`protected static <T extends Params> T`	`copyValues(T to, ParamMap extra)`
`protected static <T extends Params> ParamMap`	`copyValues$default$2()`
`protected static <T extends Params> T`	`defaultCopy(ParamMap extra)`
`static DoubleArrayParam`	`docConcentration()`
`DoubleArrayParam`	`docConcentration()` Concentration parameter (commonly named "alpha") for the prior placed on documents' distributions over topics ("theta").
`static java.lang.String`	`explainParam(Param<?> param)`
`static java.lang.String`	`explainParams()`
`static ParamMap`	`extractParamMap()`
`static ParamMap`	`extractParamMap(ParamMap extra)`
`static Param<java.lang.String>`	`featuresCol()`
`Param<java.lang.String>`	`featuresCol()` Param for features column name.
`LDAModel`	`fit(Dataset<?> dataset)` Fits a model to the input data.
`static <T> scala.Option<T>`	`get(Param<T> param)`
`static int`	`getCheckpointInterval()`
`int`	`getCheckpointInterval()`
`static <T> scala.Option<T>`	`getDefault(Param<T> param)`
`static double[]`	`getDocConcentration()`
`double[]`	`getDocConcentration()`
`static java.lang.String`	`getFeaturesCol()`
`java.lang.String`	`getFeaturesCol()`
`static int`	`getK()`
`int`	`getK()`
`static boolean`	`getKeepLastCheckpoint()`
`boolean`	`getKeepLastCheckpoint()`
`static double`	`getLearningDecay()`
`double`	`getLearningDecay()`
`static double`	`getLearningOffset()`
`double`	`getLearningOffset()`
`static int`	`getMaxIter()`
`int`	`getMaxIter()`
`static RDD<scala.Tuple2<java.lang.Object,Vector>>`	`getOldDataset(Dataset<?> dataset, java.lang.String featuresCol)` Get dataset for spark.mllib LDA
`protected static Vector`	`getOldDocConcentration()`
`Vector`	`getOldDocConcentration()` Get docConcentration used by spark.mllib LDA
`LDAOptimizer`	`getOldOptimizer()`
`protected static double`	`getOldTopicConcentration()`
`double`	`getOldTopicConcentration()` Get topicConcentration used by spark.mllib LDA
`static boolean`	`getOptimizeDocConcentration()`
`boolean`	`getOptimizeDocConcentration()`
`static java.lang.String`	`getOptimizer()`
`java.lang.String`	`getOptimizer()`
`static <T> T`	`getOrDefault(Param<T> param)`
`static Param<java.lang.Object>`	`getParam(java.lang.String paramName)`
`static long`	`getSeed()`
`long`	`getSeed()`
`static double`	`getSubsamplingRate()`
`double`	`getSubsamplingRate()`
`static double`	`getTopicConcentration()`
`double`	`getTopicConcentration()`
`static java.lang.String`	`getTopicDistributionCol()`
`java.lang.String`	`getTopicDistributionCol()`
`static <T> boolean`	`hasDefault(Param<T> param)`
`static boolean`	`hasParam(java.lang.String paramName)`
`protected static void`	`initializeLogIfNecessary(boolean isInterpreter)`
`static boolean`	`isDefined(Param<?> param)`
`static boolean`	`isSet(Param<?> param)`
`protected static boolean`	`isTraceEnabled()`
`static IntParam`	`k()`
`IntParam`	`k()` Param for the number of topics (clusters) to infer.
`static BooleanParam`	`keepLastCheckpoint()`
`BooleanParam`	`keepLastCheckpoint()` For EM optimizer only: `optimizer` = "em".
`static DoubleParam`	`learningDecay()`
`DoubleParam`	`learningDecay()` For Online optimizer only: `optimizer` = "online".
`static DoubleParam`	`learningOffset()`
`DoubleParam`	`learningOffset()` For Online optimizer only: `optimizer` = "online".
`static LDA`	`load(java.lang.String path)`
`protected static org.slf4j.Logger`	`log()`
`protected static void`	`logDebug(scala.Function0<java.lang.String> msg)`
`protected static void`	`logDebug(scala.Function0<java.lang.String> msg, java.lang.Throwable throwable)`
`protected static void`	`logError(scala.Function0<java.lang.String> msg)`
`protected static void`	`logError(scala.Function0<java.lang.String> msg, java.lang.Throwable throwable)`
`protected static void`	`logInfo(scala.Function0<java.lang.String> msg)`
`protected static void`	`logInfo(scala.Function0<java.lang.String> msg, java.lang.Throwable throwable)`
`protected static java.lang.String`	`logName()`
`protected static void`	`logTrace(scala.Function0<java.lang.String> msg)`
`protected static void`	`logTrace(scala.Function0<java.lang.String> msg, java.lang.Throwable throwable)`
`protected static void`	`logWarning(scala.Function0<java.lang.String> msg)`
`protected static void`	`logWarning(scala.Function0<java.lang.String> msg, java.lang.Throwable throwable)`
`static IntParam`	`maxIter()`
`IntParam`	`maxIter()` Param for maximum number of iterations (>= 0).
`static BooleanParam`	`optimizeDocConcentration()`
`BooleanParam`	`optimizeDocConcentration()` For Online optimizer only (currently): `optimizer` = "online".
`static Param<java.lang.String>`	`optimizer()`
`Param<java.lang.String>`	`optimizer()` Optimizer or inference algorithm used to estimate the LDA model.
`static Param<?>[]`	`params()`
`static void`	`save(java.lang.String path)`
`static LongParam`	`seed()`
`LongParam`	`seed()` Param for random seed.
`static <T> Params`	`set(Param<T> param, T value)`
`protected static Params`	`set(ParamPair<?> paramPair)`
`protected static Params`	`set(java.lang.String param, java.lang.Object value)`
`LDA`	`setCheckpointInterval(int value)`
`protected static <T> Params`	`setDefault(Param<T> param, T value)`
`protected static Params`	`setDefault(scala.collection.Seq<ParamPair<?>> paramPairs)`
`LDA`	`setDocConcentration(double value)`
`LDA`	`setDocConcentration(double[] value)`
`LDA`	`setFeaturesCol(java.lang.String value)` The features for LDA should be a `Vector` representing the word counts in a document.
`LDA`	`setK(int value)`
`LDA`	`setKeepLastCheckpoint(boolean value)`
`LDA`	`setLearningDecay(double value)`
`LDA`	`setLearningOffset(double value)`
`LDA`	`setMaxIter(int value)`
`LDA`	`setOptimizeDocConcentration(boolean value)`
`LDA`	`setOptimizer(java.lang.String value)`
`LDA`	`setSeed(long value)`
`LDA`	`setSubsamplingRate(double value)`
`LDA`	`setTopicConcentration(double value)`
`LDA`	`setTopicDistributionCol(java.lang.String value)`
`static DoubleParam`	`subsamplingRate()`
`DoubleParam`	`subsamplingRate()` For Online optimizer only: `optimizer` = "online".
`static java.lang.String[]`	`supportedOptimizers()`
`java.lang.String[]`	`supportedOptimizers()` Supported values for Param `optimizer`.
`static DoubleParam`	`topicConcentration()`
`DoubleParam`	`topicConcentration()` Concentration parameter (commonly named "beta" or "eta") for the prior placed on topics' distributions over terms.
`static Param<java.lang.String>`	`topicDistributionCol()`
`Param<java.lang.String>`	`topicDistributionCol()` Output column with estimates of the topic mixture distribution for each document (often called "theta" in the literature).
`static java.lang.String`	`toString()`
`StructType`	`transformSchema(StructType schema)` :: DeveloperApi ::
`java.lang.String`	`uid()` An immutable unique ID for the object and its derivatives.
`protected static StructType`	`validateAndTransformSchema(StructType schema)`
`StructType`	`validateAndTransformSchema(StructType schema)` Validates and transforms the input schema.
`static void`	`validateParams()`
`static MLWriter`	`write()`

Methods inherited from class org.apache.spark.ml.Estimator
fit, fit, fit, fit

Methods inherited from class org.apache.spark.ml.PipelineStage
transformSchema

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.apache.spark.ml.param.Params
clear, copyValues, defaultCopy, defaultParamMap, explainParam, explainParams, extractParamMap, extractParamMap, get, getDefault, getOrDefault, getParam, hasDefault, hasParam, isDefined, isSet, paramMap, params, set, set, set, setDefault, setDefault, shouldOwn, validateParams

Methods inherited from interface org.apache.spark.ml.util.Identifiable
toString

- Constructor Detail
  - LDA
```
public LDA(java.lang.String uid)
```
  - LDA
```
public LDA()
```
- Method Detail
  - getOldDataset
```
public static RDD<scala.Tuple2<java.lang.Object,Vector>> getOldDataset(Dataset<?> dataset,
                                                       java.lang.String featuresCol)
```
    Get dataset for spark.mllib LDA
  - load
```
public static LDA load(java.lang.String path)
```
  - toString
```
public static java.lang.String toString()
```
  - params
```
public static Param<?>[] params()
```
  - validateParams
```
public static void validateParams()
```
  - explainParam
```
public static java.lang.String explainParam(Param<?> param)
```
  - explainParams
```
public static java.lang.String explainParams()
```
  - isSet
```
public static final boolean isSet(Param<?> param)
```
  - isDefined
```
public static final boolean isDefined(Param<?> param)
```
  - hasParam
```
public static boolean hasParam(java.lang.String paramName)
```
  - getParam
```
public static Param<java.lang.Object> getParam(java.lang.String paramName)
```
  - set
```
public static final <T> Params set(Param<T> param,
             T value)
```
  - set
```
protected static final Params set(java.lang.String param,
         java.lang.Object value)
```
  - set
```
protected static final Params set(ParamPair<?> paramPair)
```
  - get
```
public static final <T> scala.Option<T> get(Param<T> param)
```
  - clear
```
public static final Params clear(Param<?> param)
```
  - getOrDefault
```
public static final <T> T getOrDefault(Param<T> param)
```
  - $
```
protected static final <T> T $(Param<T> param)
```
  - setDefault
```
protected static final <T> Params setDefault(Param<T> param,
                    T value)
```
  - setDefault
```
protected static final Params setDefault(scala.collection.Seq<ParamPair<?>> paramPairs)
```
  - getDefault
```
public static final <T> scala.Option<T> getDefault(Param<T> param)
```
  - hasDefault
```
public static final <T> boolean hasDefault(Param<T> param)
```
  - defaultCopy
```
protected static final <T extends Params> T defaultCopy(ParamMap extra)
```
  - extractParamMap
```
public static final ParamMap extractParamMap(ParamMap extra)
```
  - extractParamMap
```
public static final ParamMap extractParamMap()
```
  - copyValues
```
protected static <T extends Params> T copyValues(T to,
                              ParamMap extra)
```
  - copyValues$default$2
```
protected static <T extends Params> ParamMap copyValues$default$2()
```
  - logName
```
protected static java.lang.String logName()
```
  - log
```
protected static org.slf4j.Logger log()
```
  - logInfo
```
protected static void logInfo(scala.Function0<java.lang.String> msg)
```
  - logDebug
```
protected static void logDebug(scala.Function0<java.lang.String> msg)
```
  - logTrace
```
protected static void logTrace(scala.Function0<java.lang.String> msg)
```
  - logWarning
```
protected static void logWarning(scala.Function0<java.lang.String> msg)
```
  - logError
```
protected static void logError(scala.Function0<java.lang.String> msg)
```
  - logInfo
```
protected static void logInfo(scala.Function0<java.lang.String> msg,
           java.lang.Throwable throwable)
```
  - logDebug
```
protected static void logDebug(scala.Function0<java.lang.String> msg,
            java.lang.Throwable throwable)
```
  - logTrace
```
protected static void logTrace(scala.Function0<java.lang.String> msg,
            java.lang.Throwable throwable)
```
  - logWarning
```
protected static void logWarning(scala.Function0<java.lang.String> msg,
              java.lang.Throwable throwable)
```
  - logError
```
protected static void logError(scala.Function0<java.lang.String> msg,
            java.lang.Throwable throwable)
```
  - isTraceEnabled
```
protected static boolean isTraceEnabled()
```
  - initializeLogIfNecessary
```
protected static void initializeLogIfNecessary(boolean isInterpreter)
```
  - featuresCol
```
public static final Param<java.lang.String> featuresCol()
```
  - getFeaturesCol
```
public static final java.lang.String getFeaturesCol()
```
  - maxIter
```
public static final IntParam maxIter()
```
  - getMaxIter
```
public static final int getMaxIter()
```
  - seed
```
public static final LongParam seed()
```
  - getSeed
```
public static final long getSeed()
```
  - checkpointInterval
```
public static final IntParam checkpointInterval()
```
  - getCheckpointInterval
```
public static final int getCheckpointInterval()
```
  - k
```
public static final IntParam k()
```
  - getK
```
public static int getK()
```
  - docConcentration
```
public static final DoubleArrayParam docConcentration()
```
  - getDocConcentration
```
public static double[] getDocConcentration()
```
  - getOldDocConcentration
```
protected static Vector getOldDocConcentration()
```
  - topicConcentration
```
public static final DoubleParam topicConcentration()
```
  - getTopicConcentration
```
public static double getTopicConcentration()
```
  - getOldTopicConcentration
```
protected static double getOldTopicConcentration()
```
  - supportedOptimizers
```
public static final java.lang.String[] supportedOptimizers()
```
  - optimizer
```
public static final Param<java.lang.String> optimizer()
```
  - getOptimizer
```
public static java.lang.String getOptimizer()
```
  - topicDistributionCol
```
public static final Param<java.lang.String> topicDistributionCol()
```
  - getTopicDistributionCol
```
public static java.lang.String getTopicDistributionCol()
```
  - learningOffset
```
public static final DoubleParam learningOffset()
```
  - getLearningOffset
```
public static double getLearningOffset()
```
  - learningDecay
```
public static final DoubleParam learningDecay()
```
  - getLearningDecay
```
public static double getLearningDecay()
```
  - subsamplingRate
```
public static final DoubleParam subsamplingRate()
```
  - getSubsamplingRate
```
public static double getSubsamplingRate()
```
  - optimizeDocConcentration
```
public static final BooleanParam optimizeDocConcentration()
```
  - getOptimizeDocConcentration
```
public static boolean getOptimizeDocConcentration()
```
  - keepLastCheckpoint
```
public static final BooleanParam keepLastCheckpoint()
```
  - getKeepLastCheckpoint
```
public static boolean getKeepLastCheckpoint()
```
  - validateAndTransformSchema
```
protected static StructType validateAndTransformSchema(StructType schema)
```
  - save
```
public static void save(java.lang.String path)
                 throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - write
```
public static MLWriter write()
```
  - uid
```
public java.lang.String uid()
```
    Description copied from interface: Identifiable
    
    An immutable unique ID for the object and its derivatives.
    
    Specified by:
    
    uid in interface Identifiable
    
    Returns:
    (undocumented)
  - setFeaturesCol
```
public LDA setFeaturesCol(java.lang.String value)
```
    The features for LDA should be a Vector representing the word counts in a document. The vector should be of length vocabSize, with counts for each term (word).
    
    Parameters:
    value - (undocumented)
    
    Returns:
    (undocumented)
  - setMaxIter
```
public LDA setMaxIter(int value)
```
  - setSeed
```
public LDA setSeed(long value)
```
  - setCheckpointInterval
```
public LDA setCheckpointInterval(int value)
```
  - setK
```
public LDA setK(int value)
```
  - setDocConcentration
```
public LDA setDocConcentration(double[] value)
```
  - setDocConcentration
```
public LDA setDocConcentration(double value)
```
  - setTopicConcentration
```
public LDA setTopicConcentration(double value)
```
  - setOptimizer
```
public LDA setOptimizer(java.lang.String value)
```
  - setTopicDistributionCol
```
public LDA setTopicDistributionCol(java.lang.String value)
```
  - setLearningOffset
```
public LDA setLearningOffset(double value)
```
  - setLearningDecay
```
public LDA setLearningDecay(double value)
```
  - setSubsamplingRate
```
public LDA setSubsamplingRate(double value)
```
  - setOptimizeDocConcentration
```
public LDA setOptimizeDocConcentration(boolean value)
```
  - setKeepLastCheckpoint
```
public LDA setKeepLastCheckpoint(boolean value)
```
  - copy
```
public LDA copy(ParamMap extra)
```
    Description copied from interface: Params
    
    Creates a copy of this instance with the same UID and some extra params. Subclasses should implement this method and set the return type properly.
    
    Specified by:
    
    copy in interface Params
    
    Specified by:
    
    copy in class Estimator<LDAModel>
    
    Parameters:
    extra - (undocumented)
    
    Returns:
    (undocumented)
    See Also:
    defaultCopy()
  - fit
```
public LDAModel fit(Dataset<?> dataset)
```
    Description copied from class: Estimator
    
    Fits a model to the input data.
    
    Specified by:
    
    fit in class Estimator<LDAModel>
    
    Parameters:
    dataset - (undocumented)
    
    Returns:
    (undocumented)
  - transformSchema
```
public StructType transformSchema(StructType schema)
```
    Description copied from class: PipelineStage
    
    :: DeveloperApi ::
    Derives the output schema from the input schema.
    
    Specified by:
    
    transformSchema in class PipelineStage
    
    Parameters:
    schema - (undocumented)
    
    Returns:
    (undocumented)
  - k
```
public IntParam k()
```
    Param for the number of topics (clusters) to infer. Must be > 1. Default: 10.
    
    Returns:
    (undocumented)
  - getK
```
public int getK()
```
  - docConcentration
```
public DoubleArrayParam docConcentration()
```
    Concentration parameter (commonly named "alpha") for the prior placed on documents' distributions over topics ("theta").
    This is the parameter to a Dirichlet distribution, where larger values mean more smoothing (more regularization).
    If not set by the user, then docConcentration is set automatically. If set to singleton vector [alpha], then alpha is replicated to a vector of length k in fitting. Otherwise, the docConcentration vector must be length k. (default = automatic)
    Optimizer-specific parameter settings: - EM - Currently only supports symmetric distributions, so all values in the vector should be the same. - Values should be > 1.0 - default = uniformly (50 / k) + 1, where 50/k is common in LDA libraries and +1 follows from Asuncion et al. (2009), who recommend a +1 adjustment for EM. - Online - Values should be >= 0 - default = uniformly (1.0 / k), following the implementation from https://github.com/Blei-Lab/onlineldavb.
    
    Returns:
    (undocumented)
  - getDocConcentration
```
public double[] getDocConcentration()
```
  - getOldDocConcentration
```
public Vector getOldDocConcentration()
```
    Get docConcentration used by spark.mllib LDA
  - topicConcentration
```
public DoubleParam topicConcentration()
```
    Concentration parameter (commonly named "beta" or "eta") for the prior placed on topics' distributions over terms.
    This is the parameter to a symmetric Dirichlet distribution.
    Note: The topics' distributions over terms are called "beta" in the original LDA paper by Blei et al., but are called "phi" in many later papers such as Asuncion et al., 2009.
    If not set by the user, then topicConcentration is set automatically. (default = automatic)
    Optimizer-specific parameter settings: - EM - Value should be > 1.0 - default = 0.1 + 1, where 0.1 gives a small amount of smoothing and +1 follows Asuncion et al. (2009), who recommend a +1 adjustment for EM. - Online - Value should be >= 0 - default = (1.0 / k), following the implementation from https://github.com/Blei-Lab/onlineldavb.
    
    Returns:
    (undocumented)
  - getTopicConcentration
```
public double getTopicConcentration()
```
  - getOldTopicConcentration
```
public double getOldTopicConcentration()
```
    Get topicConcentration used by spark.mllib LDA
  - supportedOptimizers
```
public java.lang.String[] supportedOptimizers()
```
    Supported values for Param optimizer.
  - optimizer
```
public Param<java.lang.String> optimizer()
```
    Optimizer or inference algorithm used to estimate the LDA model. Currently supported (case-insensitive): - "online": Online Variational Bayes (default) - "em": Expectation-Maximization
    For details, see the following papers: - Online LDA: Hoffman, Blei and Bach. "Online Learning for Latent Dirichlet Allocation." Neural Information Processing Systems, 2010. http://www.cs.columbia.edu/~blei/papers/HoffmanBleiBach2010b.pdf - EM: Asuncion et al. "On Smoothing and Inference for Topic Models." Uncertainty in Artificial Intelligence, 2009. http://arxiv.org/pdf/1205.2662.pdf
    
    Returns:
    (undocumented)
  - getOptimizer
```
public java.lang.String getOptimizer()
```
  - topicDistributionCol
```
public Param<java.lang.String> topicDistributionCol()
```
    Output column with estimates of the topic mixture distribution for each document (often called "theta" in the literature). Returns a vector of zeros for an empty document.
    This uses a variational approximation following Hoffman et al. (2010), where the approximate distribution is called "gamma." Technically, this method returns this approximation "gamma" for each document.
    
    Returns:
    (undocumented)
  - getTopicDistributionCol
```
public java.lang.String getTopicDistributionCol()
```
  - learningOffset
```
public DoubleParam learningOffset()
```
    For Online optimizer only: optimizer = "online".
    A (positive) learning parameter that downweights early iterations. Larger values make early iterations count less. This is called "tau0" in the Online LDA paper (Hoffman et al., 2010) Default: 1024, following Hoffman et al.
    
    Returns:
    (undocumented)
  - getLearningOffset
```
public double getLearningOffset()
```
  - learningDecay
```
public DoubleParam learningDecay()
```
    For Online optimizer only: optimizer = "online".
    Learning rate, set as an exponential decay rate. This should be between (0.5, 1.0] to guarantee asymptotic convergence. This is called "kappa" in the Online LDA paper (Hoffman et al., 2010). Default: 0.51, based on Hoffman et al.
    
    Returns:
    (undocumented)
  - getLearningDecay
```
public double getLearningDecay()
```
  - subsamplingRate
```
public DoubleParam subsamplingRate()
```
    For Online optimizer only: optimizer = "online".
    Fraction of the corpus to be sampled and used in each iteration of mini-batch gradient descent, in range (0, 1].
    Note that this should be adjusted in synch with LDA.maxIter so the entire corpus is used. Specifically, set both so that maxIterations * miniBatchFraction >= 1.
    Note: This is the same as the miniBatchFraction parameter in OnlineLDAOptimizer.
    Default: 0.05, i.e., 5% of total documents.
    
    Returns:
    (undocumented)
  - getSubsamplingRate
```
public double getSubsamplingRate()
```
  - optimizeDocConcentration
```
public BooleanParam optimizeDocConcentration()
```
    For Online optimizer only (currently): optimizer = "online".
    Indicates whether the docConcentration (Dirichlet parameter for document-topic distribution) will be optimized during training. Setting this to true will make the model more expressive and fit the training data better. Default: false
    
    Returns:
    (undocumented)
  - getOptimizeDocConcentration
```
public boolean getOptimizeDocConcentration()
```
  - keepLastCheckpoint
```
public BooleanParam keepLastCheckpoint()
```
    For EM optimizer only: optimizer = "em".
    If using checkpointing, this indicates whether to keep the last checkpoint. If false, then the checkpoint will be deleted. Deleting the checkpoint can cause failures if a data partition is lost, so set this bit with care. Note that checkpoints will be cleaned up via reference counting, regardless.
    See DistributedLDAModel.getCheckpointFiles for getting remaining checkpoints and DistributedLDAModel.deleteCheckpointFiles for removing remaining checkpoints.
    Default: true
    
    Returns:
    (undocumented)
  - getKeepLastCheckpoint
```
public boolean getKeepLastCheckpoint()
```
  - validateAndTransformSchema
```
public StructType validateAndTransformSchema(StructType schema)
```
    Validates and transforms the input schema.
    
    Parameters:
    schema - input schema
    
    Returns:
    output schema
  - getOldOptimizer
```
public LDAOptimizer getOldOptimizer()
```
  - featuresCol
```
public Param<java.lang.String> featuresCol()
```
    Param for features column name.
    
    Returns:
    (undocumented)
  - getFeaturesCol
```
public java.lang.String getFeaturesCol()
```
  - maxIter
```
public IntParam maxIter()
```
    Param for maximum number of iterations (>= 0).
    
    Returns:
    (undocumented)
  - getMaxIter
```
public int getMaxIter()
```
  - seed
```
public LongParam seed()
```
    Param for random seed.
    
    Returns:
    (undocumented)
  - getSeed
```
public long getSeed()
```
  - checkpointInterval
```
public IntParam checkpointInterval()
```
    Param for set checkpoint interval (>= 1) or disable checkpoint (-1). E.g. 10 means that the cache will get checkpointed every 10 iterations.
    
    Returns:
    (undocumented)
  - getCheckpointInterval
```
public int getCheckpointInterval()
```

Class LDA

Constructor Summary

Method Summary

Methods inherited from class org.apache.spark.ml.Estimator

Methods inherited from class org.apache.spark.ml.PipelineStage

Methods inherited from class java.lang.Object

Methods inherited from interface org.apache.spark.ml.param.Params

Methods inherited from interface org.apache.spark.ml.util.Identifiable

Constructor Detail

LDA

LDA

Method Detail

getOldDataset

load

toString

params

validateParams

explainParam

explainParams

isSet

isDefined

hasParam

getParam

set

set

set

get

clear

getOrDefault

$

setDefault

setDefault

getDefault

hasDefault

defaultCopy

extractParamMap

extractParamMap

copyValues

copyValues$default$2

logName

log

logInfo

logDebug

logTrace

logWarning

logError

logInfo

logDebug

logTrace

logWarning

logError

isTraceEnabled

initializeLogIfNecessary

featuresCol

getFeaturesCol

maxIter

getMaxIter

seed

getSeed

checkpointInterval

getCheckpointInterval

k

getK

docConcentration

getDocConcentration

getOldDocConcentration

topicConcentration

getTopicConcentration

getOldTopicConcentration

supportedOptimizers

optimizer

getOptimizer

topicDistributionCol

getTopicDistributionCol

learningOffset

getLearningOffset

learningDecay

getLearningDecay

subsamplingRate

getSubsamplingRate