SequenceVectors.Builder (deeplearning4j-nlp 0.4-rc3.8 API)

java.lang.Object
- org.deeplearning4j.models.sequencevectors.SequenceVectors.Builder<T>

Direct Known Subclasses:

Glove.Builder, Word2Vec.Builder

Enclosing class:

SequenceVectors<T extends SequenceElement>
```
public static class SequenceVectors.Builder<T extends SequenceElement>
extends Object
```

Field Summary

Fields
Modifier and Type	Field and Description
`protected int`	`batchSize`
`protected VectorsConfiguration`	`configuration`
`protected ElementsLearningAlgorithm<T>`	`elementsLearningAlgorithm`
`protected boolean`	`hugeModelExpected`
`protected int`	`iterations`
`protected SequenceIterator<T>`	`iterator`
`protected int`	`layerSize`
`protected double`	`learningRate`
`protected int`	`learningRateDecayWords`
`protected WeightLookupTable<T>`	`lookupTable`
`protected double`	`minLearningRate`
`protected int`	`minWordFrequency`
`protected double`	`negative`
`protected int`	`numEpochs`
`protected boolean`	`resetModel`
`protected double`	`sampling`
`protected long`	`seed`
`protected SequenceLearningAlgorithm<T>`	`sequenceLearningAlgorithm`
`protected List<String>`	`stopWords`
`protected boolean`	`trainElementsVectors`
`protected boolean`	`trainSequenceVectors`
`protected boolean`	`useAdaGrad`
`protected VocabCache<T>`	`vocabCache`
`protected int`	`window`
`protected int`	`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
Modifier and Type	Method and Description
`SequenceVectors.Builder<T>`	`batchSize(int batchSize)` This method defines batchSize option, viable only if iterations > 1
`SequenceVectors<T>`	`build()` Build SequenceVectors instance with defined settings/options
`SequenceVectors.Builder<T>`	`elementsLearningAlgorithm(ElementsLearningAlgorithm<T> algorithm)` * Sets specific LearningAlgorithm as Elements Learning Algorithm
`SequenceVectors.Builder<T>`	`elementsLearningAlgorithm(String algoName)` * Sets specific LearningAlgorithm as Elements Learning Algorithm
`SequenceVectors.Builder<T>`	`epochs(int numEpochs)` This method defines how much iterations should be done over whole training corpus during modelling
`SequenceVectors.Builder<T>`	`iterate(SequenceIterator<T> iterator)` This method defines SequenceIterator to be used for model building
`SequenceVectors.Builder<T>`	`iterations(int iterations)` This method defines how much iterations should be done over batched sequences.
`SequenceVectors.Builder<T>`	`layerSize(int layerSize)` This method defines number of dimensions for outcome vectors.
`SequenceVectors.Builder<T>`	`learningRate(double learningRate)` This method defines initial learning rate.
`SequenceVectors.Builder<T>`	`lookupTable(WeightLookupTable<T> lookupTable)` You can pass externally built WeightLookupTable, containing model weights and vocabulary.
`SequenceVectors.Builder<T>`	`minLearningRate(double minLearningRate)` This method defines minimum learning rate after decay being applied.
`SequenceVectors.Builder<T>`	`minWordFrequency(int minWordFrequency)` This method defines minimal element frequency for elements found in the training corpus.
`SequenceVectors.Builder<T>`	`negativeSample(double negative)` This method defines negative sampling value for skip-gram algorithm.
`protected void`	`presetTables()` This method creates new WeightLookupTable and VocabCache if there were none set
`SequenceVectors.Builder<T>`	`resetModel(boolean reallyReset)` This method defines, should all model be reset before training.
`SequenceVectors.Builder<T>`	`sampling(double sampling)` This method defines sub-sampling threshold.
`SequenceVectors.Builder<T>`	`seed(long randomSeed)` Sets seed for random numbers generator.
`SequenceVectors.Builder<T>`	`sequenceLearningAlgorithm(SequenceLearningAlgorithm<T> algorithm)` Sets specific LearningAlgorithm as Sequence Learning Algorithm
`SequenceVectors.Builder<T>`	`sequenceLearningAlgorithm(String algoName)` Sets specific LearningAlgorithm as Sequence Learning Algorithm
`SequenceVectors.Builder<T>`	`stopWords(Collection<T> 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
`SequenceVectors.Builder<T>`	`stopWords(List<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
`SequenceVectors.Builder<T>`	`trainElementsRepresentation(boolean trainElements)`
`SequenceVectors.Builder<T>`	`trainSequencesRepresentation(boolean trainSequences)`
`SequenceVectors.Builder<T>`	`useAdaGrad(boolean reallyUse)` This method defines if Adaptive Gradients should be used in calculations
`SequenceVectors.Builder<T>`	`vocabCache(VocabCache<T> vocabCache)` You can pass externally built vocabCache object, containing vocabulary
`SequenceVectors.Builder<T>`	`windowSize(int windowSize)` Sets window size for skip-Gram training
`SequenceVectors.Builder<T>`	`workers(int numWorkers)` Sets number of worker threads to be used in calculations

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

Field Detail

vocabCache

protected VocabCache<T extends SequenceElement> vocabCache

lookupTable

protected WeightLookupTable<T extends SequenceElement> lookupTable

iterator

protected SequenceIterator<T extends SequenceElement> iterator

sampling
```
protected double sampling
```

negative
```
protected double negative
```

learningRate
```
protected double learningRate
```

minLearningRate
```
protected double minLearningRate
```

minWordFrequency
```
protected int minWordFrequency
```

iterations
```
protected int iterations
```

numEpochs
```
protected int numEpochs
```

layerSize
```
protected int layerSize
```

window
```
protected int window
```

hugeModelExpected
```
protected boolean hugeModelExpected
```

batchSize
```
protected int batchSize
```

learningRateDecayWords
```
protected int learningRateDecayWords
```

seed
```
protected long seed
```

useAdaGrad
```
protected boolean useAdaGrad
```

resetModel
```
protected boolean resetModel
```

workers
```
protected int workers
```

trainSequenceVectors
```
protected boolean trainSequenceVectors
```

trainElementsVectors
```
protected boolean trainElementsVectors
```

stopWords
```
protected List<String> stopWords
```

configuration

protected VectorsConfiguration configuration

elementsLearningAlgorithm

protected ElementsLearningAlgorithm<T extends SequenceElement> elementsLearningAlgorithm

sequenceLearningAlgorithm

protected SequenceLearningAlgorithm<T extends SequenceElement> sequenceLearningAlgorithm

Constructor Detail

Builder
```
public Builder()
```

Builder

public Builder(@NonNull
               VectorsConfiguration configuration)

Method Detail
- iterate
```
public SequenceVectors.Builder<T> iterate(@NonNull
                                          SequenceIterator<T> iterator)
```
  This method defines SequenceIterator to be used for model building
  
  Parameters:
  
  iterator -
  
  Returns:
- sequenceLearningAlgorithm
```
public SequenceVectors.Builder<T> sequenceLearningAlgorithm(@NonNull
                                                            String algoName)
```
  Sets specific LearningAlgorithm as Sequence Learning Algorithm
  
  Parameters:
  
  algoName - fully qualified class name
  
  Returns:
- sequenceLearningAlgorithm
```
public SequenceVectors.Builder<T> sequenceLearningAlgorithm(@NonNull
                                                            SequenceLearningAlgorithm<T> algorithm)
```
  Sets specific LearningAlgorithm as Sequence Learning Algorithm
  
  Parameters:
  
  algorithm - SequenceLearningAlgorithm implementation
  
  Returns:
- elementsLearningAlgorithm
```
public SequenceVectors.Builder<T> elementsLearningAlgorithm(@NonNull
                                                            String algoName)
```
  * Sets specific LearningAlgorithm as Elements Learning Algorithm
  
  Parameters:
  
  algoName - fully qualified class name
  
  Returns:
- elementsLearningAlgorithm
```
public SequenceVectors.Builder<T> elementsLearningAlgorithm(@NonNull
                                                            ElementsLearningAlgorithm<T> algorithm)
```
  * Sets specific LearningAlgorithm as Elements Learning Algorithm
  
  Parameters:
  
  algorithm - ElementsLearningAlgorithm implementation
  
  Returns:
- batchSize
```
public SequenceVectors.Builder<T> batchSize(int batchSize)
```
  This method defines batchSize option, viable only if iterations > 1
  
  Parameters:
  
  batchSize -
  
  Returns:
- iterations
```
public SequenceVectors.Builder<T> iterations(int iterations)
```
  This method defines how much iterations should be done over batched sequences.
  
  Parameters:
  
  iterations -
  
  Returns:
- epochs
```
public SequenceVectors.Builder<T> epochs(int numEpochs)
```
  This method defines how much iterations should be done over whole training corpus during modelling
  
  Parameters:
  
  numEpochs -
  
  Returns:
- workers
```
public SequenceVectors.Builder<T> workers(int numWorkers)
```
  Sets number of worker threads to be used in calculations
  
  Parameters:
  
  numWorkers -
  
  Returns:
- useAdaGrad
```
public SequenceVectors.Builder<T> useAdaGrad(boolean reallyUse)
```
  This method defines if Adaptive Gradients should be used in calculations
  
  Parameters:
  
  reallyUse -
  
  Returns:
- layerSize
```
public SequenceVectors.Builder<T> layerSize(int layerSize)
```
  This method defines number of dimensions for outcome vectors. Please note: This option has effect only if lookupTable wasn't defined during building process.
  
  Parameters:
  
  layerSize -
  
  Returns:
- learningRate
```
public SequenceVectors.Builder<T> learningRate(double learningRate)
```
  This method defines initial learning rate. Default value is 0.025
  
  Parameters:
  
  learningRate -
  
  Returns:
- minWordFrequency
```
public SequenceVectors.Builder<T> minWordFrequency(int minWordFrequency)
```
  This method defines minimal element frequency for elements found in the training corpus. All elements with frequency below this threshold will be removed before training. Please note: this method has effect only if vocabulary is built internally.
  
  Parameters:
  
  minWordFrequency -
  
  Returns:
- minLearningRate
```
public SequenceVectors.Builder<T> minLearningRate(double minLearningRate)
```
  This method defines minimum learning rate after decay being applied. Default value is 0.01
  
  Parameters:
  
  minLearningRate -
  
  Returns:
- resetModel
```
public SequenceVectors.Builder<T> resetModel(boolean reallyReset)
```
  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
  
  Parameters:
  
  reallyReset -
  
  Returns:
- vocabCache
```
public SequenceVectors.Builder<T> vocabCache(@NonNull
                                             VocabCache<T> vocabCache)
```
  You can pass externally built vocabCache object, containing vocabulary
  
  Parameters:
  
  vocabCache -
  
  Returns:
- lookupTable
```
public SequenceVectors.Builder<T> lookupTable(@NonNull
                                              WeightLookupTable<T> lookupTable)
```
  You can pass externally built WeightLookupTable, containing model weights and vocabulary.
  
  Parameters:
  
  lookupTable -
  
  Returns:
- sampling
```
public SequenceVectors.Builder<T> sampling(double sampling)
```
  This method defines sub-sampling threshold.
  
  Parameters:
  
  sampling -
  
  Returns:
- negativeSample
```
public SequenceVectors.Builder<T> negativeSample(double negative)
```
  This method defines negative sampling value for skip-gram algorithm.
  
  Parameters:
  
  negative -
  
  Returns:
- stopWords
```
public SequenceVectors.Builder<T> stopWords(@NonNull
                                            List<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
  
  Parameters:
  
  stopList -
  
  Returns:
- trainElementsRepresentation
```
public SequenceVectors.Builder<T> trainElementsRepresentation(boolean trainElements)
```
  Parameters:
  
  trainElements -
  
  Returns:
- trainSequencesRepresentation
```
public SequenceVectors.Builder<T> trainSequencesRepresentation(boolean trainSequences)
```
- stopWords
```
public SequenceVectors.Builder<T> stopWords(@NonNull
                                            Collection<T> 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
  
  Parameters:
  
  stopList -
  
  Returns:
- windowSize
```
public SequenceVectors.Builder<T> windowSize(int windowSize)
```
  Sets window size for skip-Gram training
  
  Parameters:
  
  windowSize -
  
  Returns:
- seed
```
public SequenceVectors.Builder<T> seed(long randomSeed)
```
  Sets seed for random numbers generator. Please note: this has effect only if vocabulary and WeightLookupTable is built internally
  
  Parameters:
  
  randomSeed -
  
  Returns:
- presetTables
```
protected void presetTables()
```
  This method creates new WeightLookupTable and VocabCache if there were none set
- build
```
public SequenceVectors<T> build()
```
  Build SequenceVectors instance with defined settings/options
  
  Returns:

Class SequenceVectors.Builder<T extends SequenceElement>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

vocabCache

lookupTable

iterator

sampling

negative

learningRate

minLearningRate

minWordFrequency

iterations

numEpochs

layerSize

window

hugeModelExpected

batchSize

learningRateDecayWords

seed

useAdaGrad

resetModel

workers

trainSequenceVectors

trainElementsVectors

stopWords

configuration

elementsLearningAlgorithm

sequenceLearningAlgorithm

Constructor Detail

Builder

Builder

Method Detail

iterate

sequenceLearningAlgorithm

sequenceLearningAlgorithm

elementsLearningAlgorithm

elementsLearningAlgorithm

batchSize

iterations

epochs

workers

useAdaGrad

layerSize

learningRate

minWordFrequency

minLearningRate

resetModel

vocabCache

lookupTable

sampling

negativeSample

stopWords

trainElementsRepresentation

trainSequencesRepresentation

stopWords

windowSize

seed

presetTables

build