Glove.Builder

java.lang.Object
- org.deeplearning4j.models.sequencevectors.SequenceVectors.Builder<VocabWord>
- - org.deeplearning4j.models.glove.Glove.Builder

Enclosing class:: Glove

public static class Glove.Builder
extends SequenceVectors.Builder<VocabWord>

Field Summary

Fields
Modifier and Type	Field and Description
`protected double`	`alpha`
`protected DocumentIterator`	`documentIterator`
`protected SentenceIterator`	`sentenceIterator`
`protected TokenizerFactory`	`tokenFactory`

Fields inherited from class org.deeplearning4j.models.sequencevectors.SequenceVectors.Builder
batchSize, configuration, elementsLearningAlgorithm, enableScavenger, existingVectors, hugeModelExpected, iterations, iterator, layerSize, learningRate, learningRateDecayWords, lookupTable, minLearningRate, minWordFrequency, modelUtils, negative, numEpochs, preciseWeightInit, resetModel, sampling, seed, sequenceLearningAlgorithm, STOP, stopWords, trainElementsVectors, trainSequenceVectors, UNK, unknownElement, useAdaGrad, useHierarchicSoftmax, useUnknown, variableWindows, vectorsListeners, vocabCache, window, workers

Constructor Summary

Constructors
Constructor and Description

Builder()

Builder(VectorsConfiguration configuration)

Constructors
Constructor and Description
`Builder()`
`Builder(VectorsConfiguration configuration)`

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`Glove.Builder`	`alpha(double alpha)` Parameter in exponent of weighting function; default 0.75
`Glove.Builder`	`batchSize(int batchSize)` Specifies minibatch size for training process.
`Glove`	`build()` Build SequenceVectors instance with defined settings/options
`Glove.Builder`	`epochs(int numEpochs)` Sets the number of iteration over training corpus during training
`Glove.Builder`	`iterate(DocumentIterator iterator)`
`Glove.Builder`	`iterate(SentenceIterator iterator)`
`Glove.Builder`	`iterate(SequenceIterator<VocabWord> iterator)` This method defines SequenceIterator to be used for model building
`Glove.Builder`	`iterations(int iterations)` Ierations and epochs are the same in GloVe implementation.
`Glove.Builder`	`layerSize(int layerSize)` This method defines number of dimensions for outcome vectors.
`Glove.Builder`	`learningRate(double learningRate)` This method defines initial learning rate.
`Glove.Builder`	`lookupTable(WeightLookupTable<VocabWord> lookupTable)` You can pass externally built WeightLookupTable, containing model weights and vocabulary.
`Glove.Builder`	`maxMemory(int gbytes)` This method allows you to specify maximum memory available for CoOccurrence map builder.
`Glove.Builder`	`minLearningRate(double minLearningRate)` This method defines minimum learning rate after decay being applied.
`Glove.Builder`	`minWordFrequency(int minWordFrequency)` Sets minimum word frequency during vocabulary mastering.
`Glove.Builder`	`modelUtils(ModelUtils<VocabWord> modelUtils)` Sets ModelUtils that gonna be used as provider for utility methods: similarity(), wordsNearest(), accuracy(), etc
`Glove.Builder`	`negativeSample(double negative)` Deprecated.
`Glove.Builder`	`resetModel(boolean reallyReset)` This method defines, should all model be reset before training.
`Glove.Builder`	`sampling(double sampling)` Deprecated.
`Glove.Builder`	`seed(long randomSeed)` Sets seed for random numbers generator.
`Glove.Builder`	`setVectorsListeners(java.util.Collection<VectorsListener<VocabWord>> vectorsListeners)` This method sets VectorsListeners for this SequenceVectors model
`Glove.Builder`	`shuffle(boolean reallyShuffle)` Parameter specifying, if cooccurrences list should be shuffled between training epochs
`Glove.Builder`	`stopWords(java.util.Collection<VocabWord> stopList)` You can provide collection of objects to be ignored, and excluded out of model Please note: Object labels and hashCode will be used for filtering
`Glove.Builder`	`stopWords(java.util.List<java.lang.String> stopList)` You can provide collection of objects to be ignored, and excluded out of model Please note: Object labels and hashCode will be used for filtering
`Glove.Builder`	`symmetric(boolean reallySymmetric)` Parameters specifying, if cooccurrences list should be build into both directions from any current word.
`Glove.Builder`	`tokenizerFactory(TokenizerFactory tokenizerFactory)` Sets TokenizerFactory to be used for training
`Glove.Builder`	`trainElementsRepresentation(boolean trainElements)`
`Glove.Builder`	`trainSequencesRepresentation(boolean trainSequences)` Deprecated.
`Glove.Builder`	`unknownElement(VocabWord element)` This method allows you to specify SequenceElement that will be used as UNK element, if UNK is used
`Glove.Builder`	`useAdaGrad(boolean reallyUse)` This method defines if Adaptive Gradients should be used in calculations
`Glove.Builder`	`useExistingWordVectors(WordVectors vec)` This method has no effect for GloVe
`Glove.Builder`	`useUnknown(boolean reallyUse)` This method allows you to specify, if UNK word should be used internally
`Glove.Builder`	`useVariableWindow(int... windows)` This method has no effect for ParagraphVectors
`Glove.Builder`	`vocabCache(VocabCache<VocabWord> vocabCache)` You can pass externally built vocabCache object, containing vocabulary
`Glove.Builder`	`windowSize(int windowSize)` Sets window size for skip-Gram training
`Glove.Builder`	`workers(int numWorkers)` Sets number of worker threads to be used in calculations
`Glove.Builder`	`xMax(double xMax)` Parameter specifying cutoff in weighting function; default 100.0

Methods inherited from class org.deeplearning4j.models.sequencevectors.SequenceVectors.Builder
elementsLearningAlgorithm, elementsLearningAlgorithm, enableScavenger, presetTables, sequenceLearningAlgorithm, sequenceLearningAlgorithm, useHierarchicSoftmax, usePreciseWeightInit

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

- Field Detail
  - alpha
```
protected double alpha
```
  - tokenFactory
```
protected TokenizerFactory tokenFactory
```
  - sentenceIterator
```
protected SentenceIterator sentenceIterator
```
  - documentIterator
```
protected DocumentIterator documentIterator
```
- Constructor Detail
  - Builder
```
public Builder()
```
  - Builder
```
public Builder(@NonNull
               VectorsConfiguration configuration)
```
- Method Detail
  - useExistingWordVectors
```
public Glove.Builder useExistingWordVectors(@NonNull
                                            WordVectors vec)
```
    This method has no effect for GloVe
    
    Overrides:
    
    useExistingWordVectors in class SequenceVectors.Builder<VocabWord>
    
    Parameters:
    
    vec - existing WordVectors model
    
    Returns:
  - iterate
```
public Glove.Builder iterate(@NonNull
                             SequenceIterator<VocabWord> iterator)
```
    Description copied from class: SequenceVectors.Builder
    
    This method defines SequenceIterator to be used for model building
    
    Overrides:
    
    iterate in class SequenceVectors.Builder<VocabWord>
    
    Returns:
  - batchSize
```
public Glove.Builder batchSize(int batchSize)
```
    Specifies minibatch size for training process.
    
    Overrides:
    
    batchSize in class SequenceVectors.Builder<VocabWord>
    
    Parameters:
    
    batchSize -
    
    Returns:
  - iterations
```
public Glove.Builder iterations(int iterations)
```
    Ierations and epochs are the same in GloVe implementation.
    
    Overrides:
    
    iterations in class SequenceVectors.Builder<VocabWord>
    
    Parameters:
    
    iterations -
    
    Returns:
  - epochs
```
public Glove.Builder epochs(int numEpochs)
```
    Sets the number of iteration over training corpus during training
    
    Overrides:
    
    epochs in class SequenceVectors.Builder<VocabWord>
    
    Parameters:
    
    numEpochs -
    
    Returns:
  - useAdaGrad
```
public Glove.Builder useAdaGrad(boolean reallyUse)
```
    Description copied from class: SequenceVectors.Builder
    
    This method defines if Adaptive Gradients should be used in calculations
    
    Overrides:
    
    useAdaGrad in class SequenceVectors.Builder<VocabWord>
    
    Returns:
  - layerSize
```
public Glove.Builder layerSize(int layerSize)
```
    Description copied from class: SequenceVectors.Builder
    
    This method defines number of dimensions for outcome vectors. Please note: This option has effect only if lookupTable wasn't defined during building process.
    
    Overrides:
    
    layerSize in class SequenceVectors.Builder<VocabWord>
    
    Returns:
  - learningRate
```
public Glove.Builder learningRate(double learningRate)
```
    Description copied from class: SequenceVectors.Builder
    
    This method defines initial learning rate. Default value is 0.025
    
    Overrides:
    
    learningRate in class SequenceVectors.Builder<VocabWord>
    
    Returns:
  - minWordFrequency
```
public Glove.Builder minWordFrequency(int minWordFrequency)
```
    Sets minimum word frequency during vocabulary mastering. Please note: this option is ignored, if vocabulary is built outside of GloVe
    
    Overrides:
    
    minWordFrequency in class SequenceVectors.Builder<VocabWord>
    
    Parameters:
    
    minWordFrequency -
    
    Returns:
  - minLearningRate
```
public Glove.Builder minLearningRate(double minLearningRate)
```
    Description copied from class: SequenceVectors.Builder
    
    This method defines minimum learning rate after decay being applied. Default value is 0.01
    
    Overrides:
    
    minLearningRate in class SequenceVectors.Builder<VocabWord>
    
    Returns:
  - resetModel
```
public Glove.Builder resetModel(boolean reallyReset)
```
    Description copied from class: SequenceVectors.Builder
    
    This method defines, should all model be reset before training. If set to true, vocabulary and WeightLookupTable will be reset before training, and will be built from scratches
    
    Overrides:
    
    resetModel in class SequenceVectors.Builder<VocabWord>
    
    Returns:
  - vocabCache
```
public Glove.Builder vocabCache(@NonNull
                                VocabCache<VocabWord> vocabCache)
```
    Description copied from class: SequenceVectors.Builder
    
    You can pass externally built vocabCache object, containing vocabulary
    
    Overrides:
    
    vocabCache in class SequenceVectors.Builder<VocabWord>
    
    Returns:
  - lookupTable
```
public Glove.Builder lookupTable(@NonNull
                                 WeightLookupTable<VocabWord> lookupTable)
```
    Description copied from class: SequenceVectors.Builder
    
    You can pass externally built WeightLookupTable, containing model weights and vocabulary.
    
    Overrides:
    
    lookupTable in class SequenceVectors.Builder<VocabWord>
    
    Returns:
  - sampling
```
@Deprecated
public Glove.Builder sampling(double sampling)
```
    Deprecated.
    
    Description copied from class: SequenceVectors.Builder
    
    This method defines sub-sampling threshold.
    
    Overrides:
    
    sampling in class SequenceVectors.Builder<VocabWord>
    
    Returns:
  - negativeSample
```
@Deprecated
public Glove.Builder negativeSample(double negative)
```
    Deprecated.
    
    Description copied from class: SequenceVectors.Builder
    
    This method defines negative sampling value for skip-gram algorithm.
    
    Overrides:
    
    negativeSample in class SequenceVectors.Builder<VocabWord>
    
    Returns:
  - stopWords
```
public Glove.Builder stopWords(@NonNull
                               java.util.List<java.lang.String> stopList)
```
    Description copied from class: SequenceVectors.Builder
    
    You can provide collection of objects to be ignored, and excluded out of model Please note: Object labels and hashCode will be used for filtering
    
    Overrides:
    
    stopWords in class SequenceVectors.Builder<VocabWord>
    
    Returns:
  - trainElementsRepresentation
```
public Glove.Builder trainElementsRepresentation(boolean trainElements)
```
    Overrides:
    
    trainElementsRepresentation in class SequenceVectors.Builder<VocabWord>
    
    Returns:
  - trainSequencesRepresentation
```
@Deprecated
public Glove.Builder trainSequencesRepresentation(boolean trainSequences)
```
    Deprecated.
    
    Overrides:
    
    trainSequencesRepresentation in class SequenceVectors.Builder<VocabWord>
  - stopWords
```
public Glove.Builder stopWords(@NonNull
                               java.util.Collection<VocabWord> stopList)
```
    Description copied from class: SequenceVectors.Builder
    
    You can provide collection of objects to be ignored, and excluded out of model Please note: Object labels and hashCode will be used for filtering
    
    Overrides:
    
    stopWords in class SequenceVectors.Builder<VocabWord>
    
    Returns:
  - windowSize
```
public Glove.Builder windowSize(int windowSize)
```
    Description copied from class: SequenceVectors.Builder
    
    Sets window size for skip-Gram training
    
    Overrides:
    
    windowSize in class SequenceVectors.Builder<VocabWord>
    
    Returns:
  - seed
```
public Glove.Builder seed(long randomSeed)
```
    Description copied from class: SequenceVectors.Builder
    
    Sets seed for random numbers generator. Please note: this has effect only if vocabulary and WeightLookupTable is built internally
    
    Overrides:
    
    seed in class SequenceVectors.Builder<VocabWord>
    
    Returns:
  - workers
```
public Glove.Builder workers(int numWorkers)
```
    Description copied from class: SequenceVectors.Builder
    
    Sets number of worker threads to be used in calculations
    
    Overrides:
    
    workers in class SequenceVectors.Builder<VocabWord>
    
    Returns:
  - tokenizerFactory
```
public Glove.Builder tokenizerFactory(@NonNull
                                      TokenizerFactory tokenizerFactory)
```
    Sets TokenizerFactory to be used for training
    
    Parameters:
    
    tokenizerFactory -
    
    Returns:
  - xMax
```
public Glove.Builder xMax(double xMax)
```
    Parameter specifying cutoff in weighting function; default 100.0
    
    Parameters:
    
    xMax -
    
    Returns:
  - symmetric
```
public Glove.Builder symmetric(boolean reallySymmetric)
```
    Parameters specifying, if cooccurrences list should be build into both directions from any current word.
    
    Parameters:
    
    reallySymmetric -
    
    Returns:
  - shuffle
```
public Glove.Builder shuffle(boolean reallyShuffle)
```
    Parameter specifying, if cooccurrences list should be shuffled between training epochs
    
    Parameters:
    
    reallyShuffle -
    
    Returns:
  - useVariableWindow
```
public Glove.Builder useVariableWindow(int... windows)
```
    This method has no effect for ParagraphVectors
    
    Overrides:
    
    useVariableWindow in class SequenceVectors.Builder<VocabWord>
    
    Parameters:
    
    windows -
    
    Returns:
  - alpha
```
public Glove.Builder alpha(double alpha)
```
    Parameter in exponent of weighting function; default 0.75
    
    Parameters:
    
    alpha -
    
    Returns:
  - iterate
```
public Glove.Builder iterate(@NonNull
                             SentenceIterator iterator)
```
  - iterate
```
public Glove.Builder iterate(@NonNull
                             DocumentIterator iterator)
```
  - modelUtils
```
public Glove.Builder modelUtils(@NonNull
                                ModelUtils<VocabWord> modelUtils)
```
    Sets ModelUtils that gonna be used as provider for utility methods: similarity(), wordsNearest(), accuracy(), etc
    
    Overrides:
    
    modelUtils in class SequenceVectors.Builder<VocabWord>
    
    Parameters:
    
    modelUtils - model utils to be used
    
    Returns:
  - setVectorsListeners
```
public Glove.Builder setVectorsListeners(@NonNull
                                         java.util.Collection<VectorsListener<VocabWord>> vectorsListeners)
```
    This method sets VectorsListeners for this SequenceVectors model
    
    Overrides:
    
    setVectorsListeners in class SequenceVectors.Builder<VocabWord>
    
    Parameters:
    
    vectorsListeners -
    
    Returns:
  - maxMemory
```
public Glove.Builder maxMemory(int gbytes)
```
    This method allows you to specify maximum memory available for CoOccurrence map builder. Please note: this option can be considered a debugging method. In most cases setting proper -Xmx argument set to JVM is enough to limit this algorithm. Please note: this option won't override -Xmx JVM value.
    
    Parameters:
    
    gbytes - memory limit, in gigabytes
    
    Returns:
  - unknownElement
```
public Glove.Builder unknownElement(VocabWord element)
```
    This method allows you to specify SequenceElement that will be used as UNK element, if UNK is used
    
    Overrides:
    
    unknownElement in class SequenceVectors.Builder<VocabWord>
    
    Parameters:
    
    element -
    
    Returns:
  - useUnknown
```
public Glove.Builder useUnknown(boolean reallyUse)
```
    This method allows you to specify, if UNK word should be used internally
    
    Overrides:
    
    useUnknown in class SequenceVectors.Builder<VocabWord>
    
    Parameters:
    
    reallyUse -
    
    Returns:
  - build
```
public Glove build()
```
    Description copied from class: SequenceVectors.Builder
    
    Build SequenceVectors instance with defined settings/options
    
    Overrides:
    
    build in class SequenceVectors.Builder<VocabWord>
    
    Returns:

Class Glove.Builder

Field Summary

Fields inherited from class org.deeplearning4j.models.sequencevectors.SequenceVectors.Builder

Constructor Summary

Method Summary

Methods inherited from class org.deeplearning4j.models.sequencevectors.SequenceVectors.Builder

Methods inherited from class java.lang.Object

Field Detail

alpha

tokenFactory

sentenceIterator

documentIterator

Constructor Detail

Builder

Builder

Method Detail

useExistingWordVectors

iterate

batchSize

iterations

epochs

useAdaGrad

layerSize

learningRate

minWordFrequency

minLearningRate

resetModel

vocabCache

lookupTable

sampling

negativeSample

stopWords

trainElementsRepresentation

trainSequencesRepresentation

stopWords

windowSize

seed

workers

tokenizerFactory

xMax

symmetric

shuffle

useVariableWindow

alpha

iterate

iterate

modelUtils

setVectorsListeners

maxMemory

unknownElement

useUnknown

build