Node2Vec.Builder

java.lang.Object
- org.deeplearning4j.models.sequencevectors.SequenceVectors.Builder<V>
- - org.deeplearning4j.models.node2vec.Node2Vec.Builder<V,E>

Enclosing class:: Node2Vec<V extends SequenceElement,E extends java.lang.Number>

public static class Node2Vec.Builder<V extends SequenceElement,E extends java.lang.Number>
extends SequenceVectors.Builder<V>

Field Summary
- 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(GraphWalker<V> walker, VectorsConfiguration configuration)

Constructors
Constructor and Description
`Builder(GraphWalker<V> walker, VectorsConfiguration configuration)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Node2Vec<V,E>`	`build()` Build SequenceVectors instance with defined settings/options
`Node2Vec.Builder<V,E>`	`elementsLearningAlgorithm(ElementsLearningAlgorithm<V> algorithm)` * Sets specific LearningAlgorithm as Elements Learning Algorithm
`Node2Vec.Builder<V,E>`	`elementsLearningAlgorithm(java.lang.String algoName)` * Sets specific LearningAlgorithm as Elements Learning Algorithm
`Node2Vec.Builder<V,E>`	`enableScavenger(boolean reallyEnable)` This method ebables/disables periodical vocab truncation during construction Default value: disabled
`Node2Vec.Builder<V,E>`	`epochs(int numEpochs)` This method defines how much iterations should be done over whole training corpus during modelling
`Node2Vec.Builder<V,E>`	`iterate(SequenceIterator<V> iterator)` This method defines SequenceIterator to be used for model building
`Node2Vec.Builder<V,E>`	`iterations(int iterations)` This method defines how much iterations should be done over batched sequences.
`Node2Vec.Builder<V,E>`	`layerSize(int layerSize)` This method defines number of dimensions for outcome vectors.
`Node2Vec.Builder<V,E>`	`learningRate(double learningRate)` This method defines initial learning rate.
`Node2Vec.Builder<V,E>`	`lookupTable(WeightLookupTable<V> lookupTable)` You can pass externally built WeightLookupTable, containing model weights and vocabulary.
`Node2Vec.Builder<V,E>`	`minLearningRate(double minLearningRate)` This method defines minimum learning rate after decay being applied.
`Node2Vec.Builder<V,E>`	`minWordFrequency(int minWordFrequency)` This method defines minimal element frequency for elements found in the training corpus.
`Node2Vec.Builder<V,E>`	`modelUtils(ModelUtils<V> modelUtils)` ModelUtils implementation, that will be used to access model.
`Node2Vec.Builder<V,E>`	`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
`Node2Vec.Builder<V,E>`	`resetModel(boolean reallyReset)` This method defines, should all model be reset before training.
`Node2Vec.Builder<V,E>`	`sampling(double sampling)` This method defines sub-sampling threshold.
`Node2Vec.Builder<V,E>`	`seed(long randomSeed)` Sets seed for random numbers generator.
`Node2Vec.Builder<V,E>`	`sequenceLearningAlgorithm(SequenceLearningAlgorithm<V> algorithm)` Sets specific LearningAlgorithm as Sequence Learning Algorithm
`Node2Vec.Builder<V,E>`	`sequenceLearningAlgorithm(java.lang.String algoName)` Sets specific LearningAlgorithm as Sequence Learning Algorithm
`Node2Vec.Builder<V,E>`	`setVectorsListeners(java.util.Collection<VectorsListener<V>> vectorsListeners)` This method sets VectorsListeners for this SequenceVectors model
`Node2Vec.Builder<V,E>`	`stopWords(java.util.Collection<V> 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
`Node2Vec.Builder<V,E>`	`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
`Node2Vec.Builder<V,E>`	`trainElementsRepresentation(boolean trainElements)`
`Node2Vec.Builder<V,E>`	`trainSequencesRepresentation(boolean trainSequences)`
`Node2Vec.Builder<V,E>`	`unknownElement(V element)` This method allows you to specify SequenceElement that will be used as UNK element, if UNK is used
`Node2Vec.Builder<V,E>`	`useAdaGrad(boolean reallyUse)` This method defines if Adaptive Gradients should be used in calculations
`protected Node2Vec.Builder<V,E>`	`useExistingWordVectors(WordVectors vec)` This method allows you to use pre-built WordVectors model (SkipGram or GloVe) for DBOW sequence learning.
`Node2Vec.Builder<V,E>`	`useHierarchicSoftmax(boolean reallyUse)` Enable/disable hierarchic softmax
`Node2Vec.Builder<V,E>`	`usePreciseWeightInit(boolean reallyUse)` If set to true, initial weights for elements/sequences will be derived from elements themself.
`Node2Vec.Builder<V,E>`	`useUnknown(boolean reallyUse)` This method allows you to specify, if UNK word should be used internally
`Node2Vec.Builder<V,E>`	`useVariableWindow(int... windows)` This method allows to use variable window size.
`Node2Vec.Builder<V,E>`	`vocabCache(VocabCache<V> vocabCache)` You can pass externally built vocabCache object, containing vocabulary
`Node2Vec.Builder<V,E>`	`windowSize(int windowSize)` Sets window size for skip-Gram training
`Node2Vec.Builder<V,E>`	`workers(int numWorkers)` Sets number of worker threads to be used in calculations

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

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

- Constructor Detail
  - Builder
```
public Builder(@NonNull
               GraphWalker<V> walker,
               @NonNull
               VectorsConfiguration configuration)
```
- Method Detail
  - useExistingWordVectors
```
protected Node2Vec.Builder<V,E> useExistingWordVectors(@NonNull
                                                       WordVectors vec)
```
    Description copied from class: SequenceVectors.Builder
    
    This method allows you to use pre-built WordVectors model (SkipGram or GloVe) for DBOW sequence learning. Existing model will be transferred into new model before training starts. PLEASE NOTE: This model has no effect for elements learning algorithms. Only sequence learning is affected. PLEASE NOTE: Non-normalized model is recommended to use here.
    
    Overrides:
    
    useExistingWordVectors in class SequenceVectors.Builder<V extends SequenceElement>
    
    Parameters:
    
    vec - existing WordVectors model
    
    Returns:
  - iterate
```
public Node2Vec.Builder<V,E> iterate(@NonNull
                                     SequenceIterator<V> iterator)
```
    Description copied from class: SequenceVectors.Builder
    
    This method defines SequenceIterator to be used for model building
    
    Overrides:
    
    iterate in class SequenceVectors.Builder<V extends SequenceElement>
    
    Returns:
  - sequenceLearningAlgorithm
```
public Node2Vec.Builder<V,E> sequenceLearningAlgorithm(@NonNull
                                                       java.lang.String algoName)
```
    Description copied from class: SequenceVectors.Builder
    
    Sets specific LearningAlgorithm as Sequence Learning Algorithm
    
    Overrides:
    
    sequenceLearningAlgorithm in class SequenceVectors.Builder<V extends SequenceElement>
    
    Parameters:
    
    algoName - fully qualified class name
    
    Returns:
  - sequenceLearningAlgorithm
```
public Node2Vec.Builder<V,E> sequenceLearningAlgorithm(@NonNull
                                                       SequenceLearningAlgorithm<V> algorithm)
```
    Description copied from class: SequenceVectors.Builder
    
    Sets specific LearningAlgorithm as Sequence Learning Algorithm
    
    Overrides:
    
    sequenceLearningAlgorithm in class SequenceVectors.Builder<V extends SequenceElement>
    
    Parameters:
    
    algorithm - SequenceLearningAlgorithm implementation
    
    Returns:
  - elementsLearningAlgorithm
```
public Node2Vec.Builder<V,E> elementsLearningAlgorithm(@NonNull
                                                       java.lang.String algoName)
```
    Description copied from class: SequenceVectors.Builder
    
    * Sets specific LearningAlgorithm as Elements Learning Algorithm
    
    Overrides:
    
    elementsLearningAlgorithm in class SequenceVectors.Builder<V extends SequenceElement>
    
    Parameters:
    
    algoName - fully qualified class name
    
    Returns:
  - elementsLearningAlgorithm
```
public Node2Vec.Builder<V,E> elementsLearningAlgorithm(@NonNull
                                                       ElementsLearningAlgorithm<V> algorithm)
```
    Description copied from class: SequenceVectors.Builder
    
    * Sets specific LearningAlgorithm as Elements Learning Algorithm
    
    Overrides:
    
    elementsLearningAlgorithm in class SequenceVectors.Builder<V extends SequenceElement>
    
    Parameters:
    
    algorithm - ElementsLearningAlgorithm implementation
    
    Returns:
  - iterations
```
public Node2Vec.Builder<V,E> iterations(int iterations)
```
    Description copied from class: SequenceVectors.Builder
    
    This method defines how much iterations should be done over batched sequences.
    
    Overrides:
    
    iterations in class SequenceVectors.Builder<V extends SequenceElement>
    
    Returns:
  - epochs
```
public Node2Vec.Builder<V,E> epochs(int numEpochs)
```
    Description copied from class: SequenceVectors.Builder
    
    This method defines how much iterations should be done over whole training corpus during modelling
    
    Overrides:
    
    epochs in class SequenceVectors.Builder<V extends SequenceElement>
    
    Returns:
  - workers
```
public Node2Vec.Builder<V,E> 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<V extends SequenceElement>
    
    Returns:
  - useHierarchicSoftmax
```
public Node2Vec.Builder<V,E> useHierarchicSoftmax(boolean reallyUse)
```
    Description copied from class: SequenceVectors.Builder
    
    Enable/disable hierarchic softmax
    
    Overrides:
    
    useHierarchicSoftmax in class SequenceVectors.Builder<V extends SequenceElement>
    
    Returns:
  - useAdaGrad
```
public Node2Vec.Builder<V,E> 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<V extends SequenceElement>
    
    Returns:
  - layerSize
```
public Node2Vec.Builder<V,E> 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<V extends SequenceElement>
    
    Returns:
  - learningRate
```
public Node2Vec.Builder<V,E> 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<V extends SequenceElement>
    
    Returns:
  - minWordFrequency
```
public Node2Vec.Builder<V,E> minWordFrequency(int minWordFrequency)
```
    Description copied from class: SequenceVectors.Builder
    
    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.
    
    Overrides:
    
    minWordFrequency in class SequenceVectors.Builder<V extends SequenceElement>
    
    Returns:
  - minLearningRate
```
public Node2Vec.Builder<V,E> 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<V extends SequenceElement>
    
    Returns:
  - resetModel
```
public Node2Vec.Builder<V,E> 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<V extends SequenceElement>
    
    Returns:
  - vocabCache
```
public Node2Vec.Builder<V,E> vocabCache(@NonNull
                                        VocabCache<V> vocabCache)
```
    Description copied from class: SequenceVectors.Builder
    
    You can pass externally built vocabCache object, containing vocabulary
    
    Overrides:
    
    vocabCache in class SequenceVectors.Builder<V extends SequenceElement>
    
    Returns:
  - lookupTable
```
public Node2Vec.Builder<V,E> lookupTable(@NonNull
                                         WeightLookupTable<V> lookupTable)
```
    Description copied from class: SequenceVectors.Builder
    
    You can pass externally built WeightLookupTable, containing model weights and vocabulary.
    
    Overrides:
    
    lookupTable in class SequenceVectors.Builder<V extends SequenceElement>
    
    Returns:
  - sampling
```
public Node2Vec.Builder<V,E> sampling(double sampling)
```
    Description copied from class: SequenceVectors.Builder
    
    This method defines sub-sampling threshold.
    
    Overrides:
    
    sampling in class SequenceVectors.Builder<V extends SequenceElement>
    
    Returns:
  - negativeSample
```
public Node2Vec.Builder<V,E> negativeSample(double negative)
```
    Description copied from class: SequenceVectors.Builder
    
    This method defines negative sampling value for skip-gram algorithm.
    
    Overrides:
    
    negativeSample in class SequenceVectors.Builder<V extends SequenceElement>
    
    Returns:
  - stopWords
```
public Node2Vec.Builder<V,E> 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<V extends SequenceElement>
    
    Returns:
  - trainElementsRepresentation
```
public Node2Vec.Builder<V,E> trainElementsRepresentation(boolean trainElements)
```
    Overrides:
    
    trainElementsRepresentation in class SequenceVectors.Builder<V extends SequenceElement>
    
    Returns:
  - trainSequencesRepresentation
```
public Node2Vec.Builder<V,E> trainSequencesRepresentation(boolean trainSequences)
```
    Overrides:
    
    trainSequencesRepresentation in class SequenceVectors.Builder<V extends SequenceElement>
  - stopWords
```
public Node2Vec.Builder<V,E> stopWords(@NonNull
                                       java.util.Collection<V> 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<V extends SequenceElement>
    
    Returns:
  - windowSize
```
public Node2Vec.Builder<V,E> windowSize(int windowSize)
```
    Description copied from class: SequenceVectors.Builder
    
    Sets window size for skip-Gram training
    
    Overrides:
    
    windowSize in class SequenceVectors.Builder<V extends SequenceElement>
    
    Returns:
  - seed
```
public Node2Vec.Builder<V,E> 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<V extends SequenceElement>
    
    Returns:
  - modelUtils
```
public Node2Vec.Builder<V,E> modelUtils(@NonNull
                                        ModelUtils<V> modelUtils)
```
    Description copied from class: SequenceVectors.Builder
    
    ModelUtils implementation, that will be used to access model. Methods like: similarity, wordsNearest, accuracy are provided by user-defined ModelUtils
    
    Overrides:
    
    modelUtils in class SequenceVectors.Builder<V extends SequenceElement>
    
    Parameters:
    
    modelUtils - model utils to be used
    
    Returns:
  - useUnknown
```
public Node2Vec.Builder<V,E> useUnknown(boolean reallyUse)
```
    Description copied from class: SequenceVectors.Builder
    
    This method allows you to specify, if UNK word should be used internally
    
    Overrides:
    
    useUnknown in class SequenceVectors.Builder<V extends SequenceElement>
    
    Returns:
  - unknownElement
```
public Node2Vec.Builder<V,E> unknownElement(@NonNull
                                            V element)
```
    Description copied from class: SequenceVectors.Builder
    
    This method allows you to specify SequenceElement that will be used as UNK element, if UNK is used
    
    Overrides:
    
    unknownElement in class SequenceVectors.Builder<V extends SequenceElement>
    
    Returns:
  - useVariableWindow
```
public Node2Vec.Builder<V,E> useVariableWindow(int... windows)
```
    Description copied from class: SequenceVectors.Builder
    
    This method allows to use variable window size. In this case, every batch gets processed using one of predefined window sizes
    
    Overrides:
    
    useVariableWindow in class SequenceVectors.Builder<V extends SequenceElement>
    
    Returns:
  - usePreciseWeightInit
```
public Node2Vec.Builder<V,E> usePreciseWeightInit(boolean reallyUse)
```
    Description copied from class: SequenceVectors.Builder
    
    If set to true, initial weights for elements/sequences will be derived from elements themself. However, this implies additional cycle through input iterator. Default value: FALSE
    
    Overrides:
    
    usePreciseWeightInit in class SequenceVectors.Builder<V extends SequenceElement>
    
    Returns:
  - presetTables
```
protected void presetTables()
```
    Description copied from class: SequenceVectors.Builder
    
    This method creates new WeightLookupTable and VocabCache if there were none set
    
    Overrides:
    
    presetTables in class SequenceVectors.Builder<V extends SequenceElement>
  - setVectorsListeners
```
public Node2Vec.Builder<V,E> setVectorsListeners(@NonNull
                                                 java.util.Collection<VectorsListener<V>> vectorsListeners)
```
    Description copied from class: SequenceVectors.Builder
    
    This method sets VectorsListeners for this SequenceVectors model
    
    Overrides:
    
    setVectorsListeners in class SequenceVectors.Builder<V extends SequenceElement>
    
    Returns:
  - enableScavenger
```
public Node2Vec.Builder<V,E> enableScavenger(boolean reallyEnable)
```
    Description copied from class: SequenceVectors.Builder
    
    This method ebables/disables periodical vocab truncation during construction Default value: disabled
    
    Overrides:
    
    enableScavenger in class SequenceVectors.Builder<V extends SequenceElement>
    
    Returns:
  - build
```
public Node2Vec<V,E> build()
```
    Description copied from class: SequenceVectors.Builder
    
    Build SequenceVectors instance with defined settings/options
    
    Overrides:
    
    build in class SequenceVectors.Builder<V extends SequenceElement>
    
    Returns:

Class Node2Vec.Builder<V extends SequenceElement,E extends java.lang.Number>

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

Constructor Detail

Builder

Method Detail

useExistingWordVectors

iterate

sequenceLearningAlgorithm

sequenceLearningAlgorithm

elementsLearningAlgorithm

elementsLearningAlgorithm

iterations

epochs

workers

useHierarchicSoftmax

useAdaGrad

layerSize

learningRate

minWordFrequency

minLearningRate

resetModel

vocabCache

lookupTable

sampling

negativeSample

stopWords

trainElementsRepresentation

trainSequencesRepresentation

stopWords

windowSize

seed

modelUtils

useUnknown

unknownElement

useVariableWindow

usePreciseWeightInit

presetTables

setVectorsListeners

enableScavenger

build