org.deeplearning4j.models.embeddings.learning.impl.elements

Class SkipGram<T extends SequenceElement>

java.lang.Object

org.deeplearning4j.models.embeddings.learning.impl.elements.SkipGram<T>

All Implemented Interfaces:

ElementsLearningAlgorithm<T>

public class SkipGram<T extends SequenceElement>
extends java.lang.Object
implements ElementsLearningAlgorithm<T>

Skip-Gram implementation for dl4j SequenceVectors

Field Summary

Fields

Modifier and Type	Field and Description
protected java.lang.ThreadLocal<java.util.List<org.nd4j.linalg.api.ops.aggregates.Aggregate>>	batches
protected VectorsConfiguration	configuration
protected org.nd4j.linalg.util.DeviceLocalNDArray	expTable
protected WeightLookupTable<T>	lookupTable
protected double	negative
protected double	sampling
protected org.nd4j.linalg.util.DeviceLocalNDArray	syn0
protected org.nd4j.linalg.util.DeviceLocalNDArray	syn1
protected org.nd4j.linalg.util.DeviceLocalNDArray	syn1Neg
protected org.nd4j.linalg.util.DeviceLocalNDArray	table
protected boolean	useAdaGrad
protected int[]	variableWindows
protected int	vectorLength
protected VocabCache<T>	vocabCache
protected int	window

Constructor Summary

Constructors

Constructor and Description
SkipGram() Dummy construction is required for reflection

Method Summary

Modifier and Type	Method and Description
Sequence<T>	applySubsampling(Sequence<T> sequence, java.util.concurrent.atomic.AtomicLong nextRandom)
void	configure(VocabCache<T> vocabCache, WeightLookupTable<T> lookupTable, VectorsConfiguration configuration) SkipGram initialization over given vocabulary and WeightLookupTable
void	finish()
java.util.List<org.nd4j.linalg.api.ops.aggregates.Aggregate>	getBatch()
java.lang.String	getCodeName() Returns implementation code name
boolean	isEarlyTerminationHit() SkipGram has no reasons for early termination ever.
double	iterateSample(T w1, T lastWord, java.util.concurrent.atomic.AtomicLong nextRandom, double alpha, boolean isInference, org.nd4j.linalg.api.ndarray.INDArray inferenceVector)
double	learnSequence(Sequence<T> sequence, java.util.concurrent.atomic.AtomicLong nextRandom, double learningRate) Learns sequence using SkipGram algorithm
void	pretrain(SequenceIterator<T> iterator) SkipGram doesn't involves any pretraining

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

configuration

protected VectorsConfiguration configuration

window

protected int window

useAdaGrad

protected boolean useAdaGrad

negative

protected double negative

sampling

protected double sampling

variableWindows

protected int[] variableWindows

vectorLength

protected int vectorLength

syn0

protected org.nd4j.linalg.util.DeviceLocalNDArray syn0

syn1

protected org.nd4j.linalg.util.DeviceLocalNDArray syn1

syn1Neg

protected org.nd4j.linalg.util.DeviceLocalNDArray syn1Neg

table

protected org.nd4j.linalg.util.DeviceLocalNDArray table

expTable

protected org.nd4j.linalg.util.DeviceLocalNDArray expTable

batches

protected java.lang.ThreadLocal<java.util.List<org.nd4j.linalg.api.ops.aggregates.Aggregate>> batches

Constructor Detail

SkipGram

public SkipGram()

Dummy construction is required for reflection

Method Detail

getBatch

public java.util.List<org.nd4j.linalg.api.ops.aggregates.Aggregate> getBatch()

getCodeName

public java.lang.String getCodeName()

Returns implementation code name

Specified by:

getCodeName in interface ElementsLearningAlgorithm<T extends SequenceElement>

Returns:

configure

public void configure(@NonNull
                      VocabCache<T> vocabCache,
                      @NonNull
                      WeightLookupTable<T> lookupTable,
                      @NonNull
                      VectorsConfiguration configuration)

SkipGram initialization over given vocabulary and WeightLookupTable

Specified by:

configure in interface ElementsLearningAlgorithm<T extends SequenceElement>

Parameters:

vocabCache -

lookupTable -

configuration -

pretrain

public void pretrain(SequenceIterator<T> iterator)

SkipGram doesn't involves any pretraining

Specified by:

pretrain in interface ElementsLearningAlgorithm<T extends SequenceElement>

Parameters:

iterator -

applySubsampling

public Sequence<T> applySubsampling(@NonNull
                                    Sequence<T> sequence,
                                    @NonNull
                                    java.util.concurrent.atomic.AtomicLong nextRandom)

learnSequence

public double learnSequence(@NonNull
                            Sequence<T> sequence,
                            @NonNull
                            java.util.concurrent.atomic.AtomicLong nextRandom,
                            double learningRate)

Learns sequence using SkipGram algorithm

Specified by:

learnSequence in interface ElementsLearningAlgorithm<T extends SequenceElement>

Parameters:

sequence -

nextRandom -

learningRate -

Returns:

average score for this sequence

finish

public void finish()

Specified by:

finish in interface ElementsLearningAlgorithm<T extends SequenceElement>

isEarlyTerminationHit

public boolean isEarlyTerminationHit()

SkipGram has no reasons for early termination ever.

Specified by:

isEarlyTerminationHit in interface ElementsLearningAlgorithm<T extends SequenceElement>

Returns:

iterateSample

public double iterateSample(T w1,
                            T lastWord,
                            java.util.concurrent.atomic.AtomicLong nextRandom,
                            double alpha,
                            boolean isInference,
                            org.nd4j.linalg.api.ndarray.INDArray inferenceVector)