o hH0@sddlmZddlmZddlZddlmmZddlm Z ddl m Z m Z ddl mZddlmZd gZed d d gZGd d d eZdS)) namedtuple)SequenceN)Tensor) ModuleList Sequential)Linear)ModuleAdaptiveLogSoftmaxWithLoss _ASMoutputoutputlossc seZdZUdZeed<eed<eeed<eed<eed<e ed<e ed< ddedede ededed d f fd d Z dddZ deded efddZddZded efddZded efddZZS)r uEfficient softmax approximation. As described in `Efficient softmax approximation for GPUs by Edouard Grave, Armand Joulin, Moustapha Cissé, David Grangier, and Hervé Jégou `__. Adaptive softmax is an approximate strategy for training models with large output spaces. It is most effective when the label distribution is highly imbalanced, for example in natural language modelling, where the word frequency distribution approximately follows the `Zipf's law`_. Adaptive softmax partitions the labels into several clusters, according to their frequency. These clusters may contain different number of targets each. Additionally, clusters containing less frequent labels assign lower dimensional embeddings to those labels, which speeds up the computation. For each minibatch, only clusters for which at least one target is present are evaluated. The idea is that the clusters which are accessed frequently (like the first one, containing most frequent labels), should also be cheap to compute -- that is, contain a small number of assigned labels. We highly recommend taking a look at the original paper for more details. * :attr:`cutoffs` should be an ordered Sequence of integers sorted in the increasing order. It controls number of clusters and the partitioning of targets into clusters. For example setting ``cutoffs = [10, 100, 1000]`` means that first `10` targets will be assigned to the 'head' of the adaptive softmax, targets `11, 12, ..., 100` will be assigned to the first cluster, and targets `101, 102, ..., 1000` will be assigned to the second cluster, while targets `1001, 1002, ..., n_classes - 1` will be assigned to the last, third cluster. * :attr:`div_value` is used to compute the size of each additional cluster, which is given as :math:`\left\lfloor\frac{\texttt{in\_features}}{\texttt{div\_value}^{idx}}\right\rfloor`, where :math:`idx` is the cluster index (with clusters for less frequent words having larger indices, and indices starting from :math:`1`). * :attr:`head_bias` if set to True, adds a bias term to the 'head' of the adaptive softmax. See paper for details. Set to False in the official implementation. .. warning:: Labels passed as inputs to this module should be sorted according to their frequency. This means that the most frequent label should be represented by the index `0`, and the least frequent label should be represented by the index `n_classes - 1`. .. note:: This module returns a ``NamedTuple`` with ``output`` and ``loss`` fields. See further documentation for details. .. note:: To compute log-probabilities for all classes, the ``log_prob`` method can be used. Args: in_features (int): Number of features in the input tensor n_classes (int): Number of classes in the dataset cutoffs (Sequence): Cutoffs used to assign targets to their buckets div_value (float, optional): value used as an exponent to compute sizes of the clusters. Default: 4.0 head_bias (bool, optional): If ``True``, adds a bias term to the 'head' of the adaptive softmax. Default: ``False`` Returns: ``NamedTuple`` with ``output`` and ``loss`` fields: * **output** is a Tensor of size ``N`` containing computed target log probabilities for each example * **loss** is a Scalar representing the computed negative log likelihood loss Shape: - input: :math:`(N, \texttt{in\_features})` or :math:`(\texttt{in\_features})` - target: :math:`(N)` or :math:`()` where each value satisfies :math:`0 <= \texttt{target[i]} <= \texttt{n\_classes}` - output1: :math:`(N)` or :math:`()` - output2: ``Scalar`` .. _Zipf's law: https://en.wikipedia.org/wiki/Zipf%27s_law in_features n_classescutoffs div_value head_biasheadtail@FNreturnc sz||d}tt|}t|dkrtd|t|ks?t|dks?t||dks?tt|t|ks?t dd|DrCtd||_ ||_ ||g|_ ||_ ||_|j d|_t|j d|_|j|j|_t|j |jfd|ji||_t|_t|jD]8} t|j |j | d} |j | d|j | } tt|j | fdd i|t| | fdd i|} |j| qdS) N)devicedtyperz4cutoffs should be a sequence of length larger than 0rcss|] }t||kVqdSN)int).0crm/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/torch/nn/modules/adaptive.py sz6AdaptiveLogSoftmaxWithLoss.__init__..zcutoffs should be a sequence of unique, positive integers sorted in an increasing order, where each value is between 1 and n_classes-1biasF)super__init__listlen ValueErrorsortedminmaxsetanyrrrrrshortlist_size n_clusters head_sizerrrrrangerrappend) selfrrrrrrrfactory_kwargsihszosz projection __class__rrr"tsN      z#AdaptiveLogSoftmaxWithLoss.__init__cCs.|j|jD] \}}||qdSr)rreset_parametersr)r0i2hh2orrrr8s  z+AdaptiveLogSoftmaxWithLoss.reset_parametersinput_target_cCsT|}|dkr$|d|dkrtd|dkr#td|n|dkr6|dkr5td|ntd|dk}|rB|n|d}|rK|n|d}d}|d}||} ||} dg|j} tt| dD]r} | | } | | d}|| k||k@}| }| dkrqo| dkr| d|||n=||| }| d|}|j| d|}|j| d}| d||tj|dd}|d|d}| d|| d|| 7}qo||krtd |jdd |d |d ||}tj|dd}| |d| d 7} | }|s%| d} t| |S) NrrzBInput and target should have the same size in the batch dimension.zE1D target tensor expects 2D input tensors, but found inputs with sizezE0D target tensor expects 1D input tensors, but found inputs with sizez;0D or 1D target tensor expected, multi-target not supporteddimzTarget values should be in [0, z], but values in range [z, z] were found. )r?size RuntimeError unsqueeze new_zeros new_emptyrr.r$nonzerosqueezenumel index_copy_ index_selectrr+ index_fill_F log_softmaxgatherrr'itemr(rmeanr )r0r;r<targ_dim is_batchedinputtarget used_rows batch_sizer gather_inds cutoff_valuesr2low_idxhigh_idx target_mask row_indicesrelative_target input_subsetcluster_output cluster_indexcluster_logprob local_logprob head_output head_logprobr rrrforwards~                 z"AdaptiveLogSoftmaxWithLoss.forwardc Cs||d|jf}tj|dd}|ddd|jf|ddd|jf<tt|j|jddD].\}\}}|j ||}tj|dd} | |dd|j|f d} | |dd||f<q3|S)zZGiven input tensor, and output of ``self.head``, compute the log of the full distribution.rrr>N) rDr@rrKrLr+ enumerateziprrrB) r0rRrboutrcr2 start_idxstop_idxr^r`output_logprobrrr_get_full_log_probs(&z-AdaptiveLogSoftmaxWithLoss._get_full_log_probrRcCs||}|||S)aCompute log probabilities for all :math:`\texttt{n\_classes}`. Args: input (Tensor): a minibatch of examples Returns: log-probabilities of for each class :math:`c` in range :math:`0 <= c <= \texttt{n\_classes}`, where :math:`\texttt{n\_classes}` is a parameter passed to ``AdaptiveLogSoftmaxWithLoss`` constructor. Shape: - Input: :math:`(N, \texttt{in\_features})` - Output: :math:`(N, \texttt{n\_classes})` )rrk)r0rRrbrrrlog_probs  z#AdaptiveLogSoftmaxWithLoss.log_probcCs||}tj|dd}||jk}| }|r|S|r+|||}tj|ddS|||||}tj|dd||<|S)aReturn the class with the highest probability for each example in the input minibatch. This is equivalent to ``self.log_prob(input).argmax(dim=1)``, but is more efficient in some cases. Args: input (Tensor): a minibatch of examples Returns: output (Tensor): a class with the highest probability for each example Shape: - Input: :math:`(N, \texttt{in\_features})` - Output: :math:`(N)` rr>)rtorchargmaxr+r*allrk)r0rRrbr not_in_shortlistall_in_shortlistrlrrrpredict*s     z"AdaptiveLogSoftmaxWithLoss.predict)rFNN)rN)__name__ __module__ __qualname____doc__r__annotations__r#floatboolrrrr"r8rr rdrkrlrr __classcell__rrr6rr s> W   9R) collectionsrcollections.abcrrmtorch.nn.functionalnn functionalrKr containerrrlinearrmoduler __all__r r rrrrs