Over the summer, I entered a contest in honor of the designer of the rainbow Pride flag, Gilbert Baker. It is made with laser cut letters, using the free Type With Pride typeface designed by Fontself, NYC Pride, and Animography. Download the free typeface here!
In the process of photographing my entry, I had the help of my roommates cat— Flower. It was a happy accident.


--- title: Scent-sational Display date: 2014-05-15 00:00:00 -06:00 categories: - whats-blooming layout: post blog-banner: whats-blooming-now-spring.jpg post-date: May 15, 2014 post-time: 4:29 PM blog-image: wbn-default.jpg ---
Eastern Bluestar Amsonia tabernaemontana
Along the Floral Walk, star-like flowers appear above the narrow green foliage of this perennial. The sweet-scented Wisteria in the Herb, Medicinal, and Fragrance Gardens is about to reach its peak and various perennials throughout the garden are also beginning to open up for a fantastic display, so look high and low as you walk through, you don't want to miss a single flower.
Common Cherrylaurel Prunus laurocerasus 'Otto Luyken'
In the Rose Garden these small white flowers emit an intoxicating fragrance.
Father Hugo Rose Rosa hugonis
In the Rose Garden, this once-blooming species rose has a spicy fragrance like no other.
Agincourt Beauty Lilac Syringa vulgaris 'Agincourt Beauty'
Along the Floral Walk, the cupped petals of this Lilac almost seem to reach for the sky.
Montaigne Lilac Syringa vulgaris 'Montaigne'
This double-flowered Lilac has lavender buds that open to pale-pink flowers.
Sholokhov Lilac Syringa vulgaris
This variety from Russia produces masses of pale lavender flowers.
Psgan Yellowhorn Xanthoceras sorbifolium 'Psgan'
This unique ornamental tree has fragrant flowers that change in color from yellow to red with age and can be found only in the Rose Garden.
Don't forget to walk through the Natural Area. There are many species of beautiful native flowers that line the trails.


*
A report credit means in fact one report. Only for pdf reports with more than five pages you get charged extra one credit for every additional five pages.
Prices are subject of change and can be modified in the future.
jsreport is completely open sourced solution and every contributor will get an discount to jsreport online. Aren't you contributor yet and want a discount? Visit jsreport github repository and fix a bug or even just submit one. You can also write an article about jsreport and let us now about it. Contact us and ask for an discount.
jsreport online service has no troubles with rendering millions of reports per month. If this is your case, don't hesitate to contact us for special offer.


Represents a multi-dimensional data type containing elements of a single data type.
A tensor can be constructed from a list or sequence using dsharp.tensor
let t = dsharp.tensor([[1.; -1.]; [1.; -1.]])
| Instance member | Description |
|
|
|
|
|
|
|
|
|
|
|
Each element of the object tensor is added to each corresponding element of the tensor b. The resulting tensor is returned. The shapes of the two tensors must be broadcastable.
|
|
|
Full Usage:
this.allclose (tensor, ?relativeTolerance, ?absoluteTolerance)
Parameters:
Tensor
?relativeTolerance : float
?absoluteTolerance : float
Returns: bool
|
Indicates if two tensors have the same shape and all corresponding elements are equal within the given tolerances.
|
|
A debugging routine that returns the ancestors of a tensor involved in reverse-mode automatic differentiation
|
|
Returns a tensor in the manner of
|
|
|
Returns a tensor in the manner of
|
|
|
The resulting tensor does not participate in reverse or forward differentiation. It can be used as input to another operation such as
|
Full Usage:
this.argmax ()
Returns: int[]
|
|
|
The resulting tensor does not participate in reverse or forward differentiation. It can be used as input to another operation such as
|
Full Usage:
this.argmin ()
Returns: int[]
|
|
|
|
|
|
|
|
|
|
Full Usage:
this.bceLoss (target, ?weight, ?reduction)
Parameters:
Tensor
-
The target tensor.
?weight : Tensor
-
A manual rescaling weight given to the loss of each batch element.
?reduction : string
-
Optionally specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. 'none': no reduction will be applied, 'mean': the sum of the output will be divided by the number of elements in the output, 'sum': the output will be summed. Note: size_average and reduce are in the process of being deprecated, and in the meantime, specifying either of those two args will override reduction. Default: 'mean'.
Returns: Tensor
|
|
Full Usage:
this.bernoulli (?device, ?dtype, ?backend)
Parameters:
Device
-
The desired device of returned tensor. Default: if None, uses Device.Default.
?dtype : Dtype
-
The desired element type of returned tensor. Default: if None, uses Dtype.Default.
?backend : Backend
-
The desired backend of returned tensor. Default: if None, uses Backend.Default.
Returns: Tensor
|
|
|
|
|
|
|
|
|
|
|
|
|
Returns a new tensor with the ceil of the elements of input, the smallest integer greater than or equal to each element. The tensor will have the same element type as the input tensor.
|
|
|
|
This method discards differentiability and returns a constant tensor.
|
|
|
Full Usage:
this.conv2d (filters, ?stride, ?padding, ?dilation, ?strides, ?paddings, ?dilations)
Parameters:
Tensor
-
The filters.
?stride : int
-
The stride of the convolving kernel.
?padding : int
-
The implicit padding on corresponding sides of the input.
?dilation : int
-
The spacing between kernel elements.
?strides : seq<int>
-
The strides of the convolving kernel.
?paddings : seq<int>
-
The implicit paddings on corresponding sides of the input.
?dilations : seq<int>
-
The spacings between kernel elements.
Returns: Tensor
|
|
Full Usage:
this.conv3d (filters, ?stride, ?padding, ?dilation, ?strides, ?paddings, ?dilations)
Parameters:
Tensor
-
The filters.
?stride : int
-
The stride of the convolving kernel.
?padding : int
-
The implicit padding on corresponding sides of the input.
?dilation : int
-
The spacing between kernel elements.
?strides : seq<int>
-
The strides of the convolving kernel.
?paddings : seq<int>
-
The implicit paddings on corresponding sides of the input.
?dilations : seq<int>
-
The spacings between kernel elements.
Returns: Tensor
|
|
Full Usage:
this.convTranspose1d (filters, ?stride, ?padding, ?dilation, ?outputPadding)
Parameters:
Tensor
-
The filters.
?stride : int
-
The stride of the convolving kernel.
?padding : int
-
The implicit padding on both sides of the input.
?dilation : int
-
The spacing between kernel elements.
?outputPadding : int
-
The additional size added to one side of each dimension in the output shape.
Returns: Tensor
|
Applies a 1D transposed convolution operator over an input signal composed of several input planes, sometimes also called 'deconvolution'.
|
Full Usage:
this.convTranspose2d (filters, ?stride, ?padding, ?dilation, ?outputPadding, ?strides, ?paddings, ?dilations, ?outputPaddings)
Parameters:
Tensor
-
The filters.
?stride : int
-
The stride of the convolving kernel.
?padding : int
-
The implicit padding on both sides of the input.
?dilation : int
-
The spacing between kernel elements.
?outputPadding : int
-
The additional size added to one side of each dimension in the output shape.
?strides : seq<int>
-
The strides of the convolving kernel.
?paddings : seq<int>
-
The implicit paddings on corresponding sides of the input.
?dilations : seq<int>
-
The spacings between kernel elements.
?outputPaddings : seq<int>
-
The additional sizes added to one side of each dimension in the output shape.
Returns: Tensor
|
Applies a 2D transposed convolution operator over an input signal composed of several input planes, sometimes also called 'deconvolution'.
|
Full Usage:
this.convTranspose3d (filters, ?stride, ?padding, ?dilation, ?outputPadding, ?strides, ?paddings, ?dilations, ?outputPaddings)
Parameters:
Tensor
-
The filters.
?stride : int
-
The stride of the convolving kernel.
?padding : int
-
The implicit padding on both sides of the input.
?dilation : int
-
The spacing between kernel elements.
?outputPadding : int
-
The additional size added to one side of each dimension in the output shape.
?strides : seq<int>
-
The strides of the convolving kernel.
?paddings : seq<int>
-
The implicit paddings on corresponding sides of the input.
?dilations : seq<int>
-
The spacings between kernel elements.
?outputPaddings : seq<int>
-
The additional sizes added to one side of each dimension in the output shape.
Returns: Tensor
|
Applies a 3D transposed convolution operator over an input signal composed of several input planes, sometimes also called 'deconvolution'.
|
Full Usage:
this.corrcoef ()
Returns: Tensor
The correlation coefficient matrix \(R\) is computed from the covariance
matrix
Returns a square tensor representing the correlation coefficient matrix.
Given a tensor with \(N\) variables \(X=[x_1,x_2,\ldots,x_N]\) the
\(R_{i,j}\) entry on the correlation matrix is the correlation between
\(x_i\) and \(x_j\).
|
Estimates the Pearson correlation coefficient matrix for the given tensor. The tensor's first dimension should index variables and the second dimension should index observations for each variable. The correlation between variables \(x\) and \(y\) is \[cor(x,y)= \frac{\sum^{N}_{i = 1}(x_{i} - \mu_x)(y_{i} - \mu_y)}{\sigma_x \sigma_y (N ~-~1)}\] where \(\mu_x\) and \(\mu_y\) are the sample means and \(\sigma_x\) and \(\sigma_x\) are the sample standard deviations.
Example
let x = dsharp.tensor([-0.2678; -0.0908; -0.3766; 0.2780]) let y = dsharp.tensor([-0.5812; 0.1535; 0.2387; 0.2350]) let xy = dsharp.stack([x;y]) xy.corrcoef()Evaluates to tensor([[1.0000, 0.3582], [0.3582, 1.0000]]) |
|
|
|
|
Full Usage:
this.cov (?correction, ?fweights, ?aweights)
Parameters:
int64
-
Difference between the sample size and the sample degrees of freedom. Defaults to 1 (Bessel's correction).
?fweights : Tensor
-
Frequency weights represent the number of times each observation was observed.
Should be given as a tensor of integers. Defaults to no weights.
?aweights : Tensor
-
Relative importance weights, larger weights for observations that
should have a larger effect on the estimate.
Should be given as a tensor of floating point numbers. Defaults to no weights.
Returns: Tensor
Returns a square tensor representing the covariance matrix.
Given a tensor with \(N\) variables \(X=[x_1,x_2,\ldots,x_N]\) the
\(C_{i,j}\) entry on the covariance matrix is the covariance between
\(x_i\) and \(x_j\).
|
Estimates the covariance matrix of the given tensor. The tensor's first dimension should index variables and the second dimension should index observations for each variable.
If no weights are given, the covariance between variables \(x\) and \(y\) is
\[cov(x,y)= \frac{\sum^{N}_{i = 1}(x_{i} - \mu_x)(y_{i} - \mu_y)}{N~-~\text{correction}}\]
where \(\mu_x\) and \(\mu_y\) are the sample means.
If there are fweights or aweights then the covariance is
\[cov(x,y)=\frac{\sum^{N}_{i = 1}w_i(x_{i} - \mu_x^*)(y_{i} - \mu_y^*)}{\text{normalization factor}}\]
where \(w\) is either fweights or aweights if one weight type is provided.
If both weight types are provided \(w=\text{fweights}\times\text{aweights}\).
\(\mu_x^* = \frac{\sum^{N}_{i = 1}w_ix_{i} }{\sum^{N}_{i = 1}w_i}\)
is the weighted mean of variables.
The normalization factor is \(\sum^{N}_{i=1} w_i\) if only fweights are provided or if aweights are provided and
Example
let x = dsharp.tensor([0.0;3.4;5.0]) let y = dsharp.tensor([1.0;2.3;-3.0]) let xy = dsharp.stack([x;y]) xy.cov()Evaluates to tensor([[ 6.5200, -4.0100], [-4.0100, 7.6300]]) |
|
|
Full Usage:
this.crossEntropyLoss (target, ?weight, ?reduction)
Parameters:
Tensor
-
The target tensor.
?weight : Tensor
-
A optional manual rescaling weight given to the loss of each batch element.
?reduction : string
-
Optionally specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. 'none': no reduction will be applied, 'mean': the sum of the output will be divided by the number of elements in the output, 'sum': the output will be summed. Note: size_average and reduce are in the process of being deprecated, and in the meantime, specifying either of those two args will override reduction. Default: 'mean'.
Returns: Tensor
|
|
Full Usage:
this.depth
Returns: int
|
|
Full Usage:
this.derivative
|
|
|
|
|
|
|
|
Full Usage:
this.diagonal (?offset, ?dim1, ?dim2)
Parameters:
int
?dim1 : int
?dim2 : int
Returns: Tensor
|
Returns a tensor with the diagonal elements with respect to
|
Full Usage:
this.dilate dilations
Parameters:
seq<int>
-
The dilations to use.
Returns: Tensor
|
|
Full Usage:
this.dim
Returns: int
|
|
|
The shapes of the two tensors must be broadcastable.
|
|
Divides each element of the object tensor by the corresponding element of the tensor b. The resulting tensor is returned. The shapes of the two tensors must be broadcastable.
|
|
This function does not broadcast and expects this tensor to be a vector (1d-tensor). The tensors must have the same number of elements.
|
|
|
Full Usage:
this.dropout ?p
Parameters:
double
-
The probability of an element to be zeroed. Default: 0.5.
Returns: Tensor
|
Randomly zeroes some of the elements of the input tensor with probability p using samples from a Bernoulli distribution
|
Full Usage:
this.dropout2d ?p
Parameters:
double
-
The probability of an element to be zeroed. Default: 0.5.
Returns: Tensor
|
Randomly zero out entire channels (a channel is a 2D feature map, e.g., the jj -th channel of the ii -th sample in the batched input is a 2D tensor \text{input}[i, j]input[i,j] ). Each channel will be zeroed out independently on every forward call with probability p using samples from a Bernoulli distribution
|
Full Usage:
this.dropout3d ?p
Parameters:
double
-
The probability of an element to be zeroed. Default: 0.5.
Returns: Tensor
|
Randomly zero out entire channels (a channel is a 3D feature map, e.g., the jj -th channel of the ii -th sample in the batched input is a 3D tensor \text{input}[i, j]input[i,j] ). Each channel will be zeroed out independently on every forward call with probability p using samples from a Bernoulli distribution.
|
|
|
Full Usage:
this.elementSize
Returns: int
|
Returns the size in bytes of an individual element in this tensor. Depending on dtype, backend configuration, this is not guaranteed to be correct and can behave differently in different runtime environments.
|
|
Computes element-wise \(a = b\), returning a boolean tensor containing a
|
|
|
|
|
Passing -1 as the size for a dimension means not changing the size of that dimension. The tensor can be also expanded to a larger number of dimensions, and the new ones will be appended at the front. For the new dimensions, the size cannot be set to -1. Expanding a tensor does not allocate new memory, but only creates a new view on the existing tensor where a dimension of size one is expanded to a larger size by setting the stride to 0. Any dimension of size 1 can be expanded to an arbitrary value without allocating new memory.
|
|
|
Full Usage:
this.fanout
|
|
Full Usage:
this.flatten (?startDim, ?endDim)
Parameters:
int
-
The first dim to flatten.
?endDim : int
-
The last dim to flatten.
Returns: Tensor
|
|
|
|
|
|
|
|
|
|
|
|
|
Returns a new tensor with the floor of the elements of input, the largest integer less than or equal to each element. The tensor will have the same element type as the input tensor.
|
|
Any tensors produced using this tensor will have attached derivatives for forward mode propagation. The current global nesting level is used for nested differentiation.
|
|
Returns a new tensor filled with the given scalar value for the given shape, element type and configuration, defaulting to the shape and configuration of the input tensor.
|
|
|
|
|
Computes element-wise \(a \geq b\), returning a boolean tensor containing a
|
|
|
|
|
Computes element-wise \(a > b\), returning a boolean tensor containing a
|
|
Full Usage:
this.hasinf ()
Returns: bool
|
|
Full Usage:
this.hasinfnan ()
Returns: bool
|
|
Full Usage:
this.hasnan ()
Returns: bool
|
|
|
|
|
|
|
|
|
|
|
|
Full Usage:
this.isForwardDiff
Returns: bool
|
|
Full Usage:
this.isNoDiff
Returns: bool
|
Indicates if a tensor is a constant, meaning that it is not taking part in forward or reverse-mode differentiation
|
Full Usage:
this.isReverseDiff
Returns: bool
|
|
|
|
|
|
|
Returns a new tensor with boolean elements representing if each element is NaN or not. Complex values are considered NaN when either their real and/or imaginary part is NaN.
|
|
Computes element-wise \(a \leq b\), returning a boolean tensor containing a
|
|
Full Usage:
this.leakyRelu ?negativeSlope
Parameters:
float
-
Controls the angle of the negative slope. Default: 0.01.
Returns: Tensor
|
\[\text{leakyRelu}(x) = \max(0, x) + \text{negativeSlope} * \min(0, x)\]
|
|
Returns a tensor from the .NET data in
|
|
Returns a tensor in the manner of
|
|
|
Returns a tensor in the manner of
|
|
|
\[y_{i} = \log_{e} (x_{i})\]
|
|
\[y_{i} = \log_{10} (x_{i})\]
|
Full Usage:
this.logsoftmax dim
Parameters:
int
-
A dimension along which softmax will be computed.
Returns: Tensor
|
|
|
Returns a tensor in the manner of
|
|
|
Returns a tensor in the manner of
|
|
Full Usage:
this.logsumexp (dim, ?keepDim)
Parameters:
int
-
The dimension to reduce.
?keepDim : bool
-
Whether the output tensor has dim retained or not.
Returns: Tensor
|
|
|
Computes element-wise \(a < b\), returning a boolean tensor containing a
|
|
|
The behavior depends on the dimensionality of the tensors as follows: If both tensors are 1-dimensional, the dot product (scalar) is returned. If both arguments are 2-dimensional, the matrix-matrix product is returned. If the first argument is 1-dimensional and the second argument is 2-dimensional, a 1 is prepended to its dimension for the purpose of the matrix multiply. After the matrix multiply, the prepended dimension is removed. If the first argument is 2-dimensional and the second argument is 1-dimensional, the matrix-vector product is returned. If both arguments are at least 1-dimensional and at least one argument is N-dimensional (where N > 2), then a batched matrix multiply is returned. If the first argument is 1-dimensional, a 1 is prepended to its dimension for the purpose of the batched matrix multiply and removed after. If the second argument is 1-dimensional, a 1 is appended to its dimension for the purpose of the batched matrix multiple and removed after. The non-matrix (i.e. batch) dimensions are broadcasted (and thus must be broadcastable). For example, if input is a (j \times 1 \times n \times m)(j×1×n×m) tensor and other is a (k \times m \times p)(k×m×p) tensor, out will be an (j \times k \times n \times p)(j×k×n×p) tensor.
|
|
|
|
|
|
|
Full Usage:
this.maxpool1d (kernelSize, ?stride, ?padding)
Parameters:
int
-
The size of the window to take a max over.
?stride : int
-
The stride of the window. Default value is kernelSize.
?padding : int
-
The implicit zero padding to be added on both sides.
Returns: Tensor
|
|
|
Applies a 1D max pooling over an input signal composed of several input planes, returning the max indices along with the outputs.
|
Full Usage:
this.maxpool2d (?kernelSize, ?stride, ?padding, ?kernelSizes, ?strides, ?paddings)
Parameters:
int
-
The size of the window to take a max over.
?stride : int
-
The stride of the window. Default value is kernelSize.
?padding : int
-
The implicit zero padding to be added on both sides.
?kernelSizes : seq<int>
-
The sizes of the window to take a max over.
?strides : seq<int>
-
The strides of the window. Default value is kernelSize.
?paddings : seq<int>
-
The implicit zero paddings to be added on corresponding sides.
Returns: Tensor
|
|
Full Usage:
this.maxpool2di (?kernelSize, ?stride, ?padding, ?kernelSizes, ?strides, ?paddings)
Parameters:
int
-
The size of the window to take a max over.
?stride : int
-
The stride of the window. Default value is kernelSize.
?padding : int
-
The implicit zero padding to be added on both sides.
?kernelSizes : seq<int>
-
The sizes of the window to take a max over.
?strides : seq<int>
-
The strides of the window. Default value is kernelSize.
?paddings : seq<int>
-
The implicit zero paddings to be added on corresponding sides.
Returns: Tensor * Tensor
|
Applies a 2D max pooling over an input signal composed of several input planes, returning the max indices along with the outputs.
|
Full Usage:
this.maxpool3d (?kernelSize, ?stride, ?padding, ?kernelSizes, ?strides, ?paddings)
Parameters:
int
-
The size of the window to take a max over.
?stride : int
-
The stride of the window. Default value is kernelSize.
?padding : int
-
The implicit zero padding to be added on both sides.
?kernelSizes : seq<int>
-
The sizes of the window to take a max over.
?strides : seq<int>
-
The strides of the window. Default value is kernelSizes.
?paddings : seq<int>
-
The implicit zero paddings to be added on corresponding sides.
Returns: Tensor
|
|
Full Usage:
this.maxpool3di (?kernelSize, ?stride, ?padding, ?kernelSizes, ?strides, ?paddings)
Parameters:
int
-
The size of the window to take a max over.
?stride : int
-
The stride of the window. Default value is kernelSize.
?padding : int
-
The implicit zero padding to be added on both sides.
?kernelSizes : seq<int>
-
The sizes of the window to take a max over.
?strides : seq<int>
-
The strides of the window. Default value is kernelSize.
?paddings : seq<int>
-
The implicit zero paddings to be added on corresponding sides.
Returns: Tensor * Tensor
|
Applies a 3D max pooling over an input signal composed of several input planes, returning the max indices along with the outputs.
|
Full Usage:
this.maxunpool1d (indices, kernelSize, ?stride, ?padding, ?outputSize)
Parameters:
Tensor
-
The indices selected by maxpool1di.
kernelSize : int
-
The size of the window to take a max over.
?stride : int
-
The stride of the window. Default value is kernelSize.
?padding : int
-
The implicit zero padding to be added on both sides.
?outputSize : seq<int>
-
The targeted output size.
Returns: Tensor
|
|
Full Usage:
this.maxunpool2d (indices, ?kernelSize, ?stride, ?padding, ?kernelSizes, ?strides, ?paddings, ?outputSize)
Parameters:
Tensor
-
The indices selected by maxpool2di.
?kernelSize : int
-
The size of the window to take a max over.
?stride : int
-
The stride of the window. Default value is kernelSize.
?padding : int
-
The implicit zero padding to be added on both sides.
?kernelSizes : seq<int>
-
The sizes of the window to take a max over.
?strides : seq<int>
-
The strides of the window. Default value is kernelSizes.
?paddings : seq<int>
-
The implicit zero paddings to be added on corresponding sides.
?outputSize : seq<int>
-
The targeted output size.
Returns: Tensor
|
|
Full Usage:
this.maxunpool3d (indices, ?kernelSize, ?stride, ?padding, ?kernelSizes, ?strides, ?paddings, ?outputSize)
Parameters:
Tensor
-
The indices selected by maxpool3di.
?kernelSize : int
-
The size of the window to take a max over.
?stride : int
-
The stride of the window. Default value is kernelSize.
?padding : int
-
The implicit zero padding to be added on both sides.
?kernelSizes : seq<int>
-
The sizes of the window to take a max over.
?strides : seq<int>
-
The strides of the window. Default value is kernelSizes.
?paddings : seq<int>
-
The implicit zero paddings to be added on corresponding sides.
?outputSize : seq<int>
-
The targeted output size.
Returns: Tensor
|
|
Full Usage:
this.mean (dim, ?keepDim)
Parameters:
int
-
The dimension to reduce.
?keepDim : bool
-
Whether the output tensor has dim retained or not.
Returns: Tensor
|
If keepdim is True, the output tensor is of the same size as input except in the dimension dim where it is of size 1. Otherwise, dim is squeezed, resulting in the output tensor having 1 fewer dimension.
|
|
|
Full Usage:
this.memorySize
Returns: int64
|
Returns the size in bytes of the total memory used by this tensor. Depending on dtype, backend configuration, this is not guaranteed to be correct and can behave differently in different runtime environments.
|
|
|
|
|
|
|
|
|
|
|
|
|
Full Usage:
this.mseLoss (target, ?reduction)
Parameters:
Tensor
-
The target tensor.
?reduction : string
-
Optionally specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. 'none': no reduction will be applied, 'mean': the sum of the output will be divided by the number of elements in the output, 'sum': the output will be summed. Note: size_average and reduce are in the process of being deprecated, and in the meantime, specifying either of those two args will override reduction. Default: 'mean'.
Returns: Tensor
|
Creates a criterion that measures the mean squared error (squared L2 norm) between each element in the input and the target.
|
|
The shapes of the two tensors must be broadcastable.
|
|
Multiplies each element of the object tensor by the corresponding element of the tensor b. The resulting tensor is returned. The shapes of the two tensors must be broadcastable.
|
Full Usage:
this.multinomial (numSamples, ?normalize, ?device, ?dtype, ?backend)
Parameters:
int
-
The number of samples to draw.
?normalize : bool
-
Indicates where the probabilities should first be normalized by their sum.
?device : Device
-
The desired device of returned tensor. Default: if None, uses Device.Default.
?dtype : Dtype
-
The desired element type of returned tensor. Default: if None, uses Dtype.Default.
?backend : Backend
-
The desired backend of returned tensor. Default: if None, uses Backend.Default.
Returns: Tensor
|
Returns a tensor where each row contains numSamples indices sampled from the multinomial probability distribution located in the corresponding row of tensor input.
|
|
Computes element-wise \(a \neq b\), returning a boolean tensor containing a
|
|
|
|
Full Usage:
this.nelement
Returns: int
|
|
Full Usage:
this.nestingTag
Returns: uint32
|
|
Full Usage:
this.nllLoss (target, ?weight, ?reduction)
Parameters:
Tensor
-
The target tensor.
?weight : Tensor
-
A optional manual rescaling weight given to the loss of each batch element.
?reduction : string
-
Optionally specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. 'none': no reduction will be applied, 'mean': the sum of the output will be divided by the number of elements in the output, 'sum': the output will be summed. Note: size_average and reduce are in the process of being deprecated, and in the meantime, specifying either of those two args will override reduction. Default: 'mean'.
Returns: Tensor
|
|
|
|
|
|
|
Returns a scalar '1' tensor for the given element type and configuration, defaulting to the element type and configuration of the input tensor.
|
|
Returns a tensor in the manner of
|
|
Returns a new tensor filled with '1' values for the given shape, element type and configuration, defaulting to the shape and configuration of the input tensor.
|
Full Usage:
this.pad paddings
Parameters:
seq<int>
-
The implicit paddings on corresponding sides of the input.
Returns: Tensor
|
|
|
|
Full Usage:
this.permute permutation
Parameters:
seq<int>
-
The desired ordering of dimensions.
Returns: Tensor
|
|
|
Raises each element of the self tensor to the power of the scalar b. The resulting tensor is returned.
|
|
Raises each element of the self tensor to the power of each corresponding element of the tensor b. The resulting tensor is returned. The shapes of the two tensors must be broadcastable.
|
|
|
|
|
|
|
|
Returns a new tensor with random values drawn from the uniform distribution [0,1) for the given shape, element type and configuration, defaulting to the shape and configuration of the input tensor.
|
|
Returns a new tensor with random integer values drawn from the given range, for the given shape, element type and configuration, defaulting to the shape and configuration of the input tensor.
|
|
|
Returns a new tensor with random values drawn from the standard normal distribution, for the given shape, element type and configuration, defaulting to the shape and configuration of the input tensor.
|
|
|
Full Usage:
this.repeat (dim, times)
Parameters:
int
-
The dimension along which to repeat values.
times : int
-
The number of repetitions for each element.
Returns: Tensor
|
|
Full Usage:
this.reverse (?value, ?zeroDerivatives)
Parameters:
Tensor
-
The derivative value to propagate backwards. Should have the same shape with this tensor.
?zeroDerivatives : bool
-
Indicates whether any existing derivatives in the computation graph (for example from a previous reverse propagation that was executed) should be zeroed or not before starting this propagation. Default: true
|
Propagate the reverse-mode derivative backwards in the computation graph, starting from this tensor.
|
Full Usage:
this.reverseDiff (?derivative, ?nestingTag)
Parameters:
Tensor
-
The derivative (adjoint) to assign to the new reverse-mode tensor. Defaults to an empty placeholder tensor.
?nestingTag : uint32
-
The level nestingTag for nested differentiation. Defaults to the current global nesting level
Returns: Tensor
|
Any tensors produced using this tensor will also support reverse-mode propagation. After the completion
of the corresponding
|
|
|
Full Usage:
this.reverseReset zeroDerivatives
Parameters:
bool
|
|
|
The tensor will have the same element type as the input tensor.
|
|
Returns the logarithm of the tensor after clamping the tensor so that all its elements are greater than epsilon. This is to avoid a -inf result for elements equal to zero.
|
Full Usage:
this.save fileName
Parameters:
string
|
The binary format records the elements, backend, element type and shape. It does not record the device. The format used may change from version to version of DiffSharp.
|
|
Returns a new scalar tensor for the given shape, element type and configuration, defaulting to the shape and configuration of the input tensor.
|
|
|
|
|
|
|
\[\text{sigmoid}(x) = \frac{1}{1 + \exp(-x)}\]
|
|
The tensor will have the same element type as the input tensor.
|
|
|
|
|
Full Usage:
this.softmax dim
Parameters:
int
-
A dimension along which softmax will be computed.
Returns: Tensor
|
Softmax is defined as: \text{softmax}(x_{i}) = \frac{\exp(x_i)}{\sum_j \exp(x_j)}.
|
|
\[\text{softplus}(x) = \frac{1}{\beta} * \log(1 + \exp(\beta * x))\]
|
Full Usage:
this.split (sizes, ?dim)
Parameters:
seq<int>
-
List of sizes for each chunk
?dim : int
-
The dimension along which to split the tensor, defaults to 0.
Returns: Tensor[]
|
|
|
|
Full Usage:
this.squeeze ?dim
Parameters:
int
-
If given, the input will be squeezed only in this dimension.
Returns: Tensor
|
If the tensor has a batch dimension of size 1, then squeeze(input) will also remove the batch dimension, which can lead to unexpected errors.
|
|
|
Full Usage:
this.std ?unbiased
Parameters:
bool
-
Whether to use the unbiased estimation or not.
Returns: Tensor
|
If unbiased is False, then the standard deviation will be calculated via the biased estimator. Otherwise, Bessel’s correction will be used.
|
Full Usage:
this.std (dim, ?keepDim, ?unbiased)
Parameters:
int
-
The dimension to reduce.
?keepDim : bool
-
Whether the output tensor has dim retained or not.
?unbiased : bool
-
Whether to use the unbiased estimation or not.
Returns: Tensor
|
If keepdim is True, the output tensor is of the same size as input except in the dimension dim where it is of size 1. Otherwise, dim is squeezed, resulting in the output tensor having 1 fewer dimension(s). If unbiased is False, then the standard deviation will be calculated via the biased estimator. Otherwise, Bessel’s correction will be used.
|
|
Subtracts the scalar b from the corresponding element of the object tensor. The resulting tensor is returned.
|
|
Subtracts each element of the object tensor from the corresponding element of the self tensor. The resulting tensor is returned. The shapes of the two tensors must be broadcastable.
|
|
Returns the sum of each row of the input tensor in the given dimension dim. If dim is a list of dimensions, reduce over all of them.
If keepdim is
|
|
|
|
|
Full Usage:
this.summary ()
Returns: string
|
|
|
|
|
|
|
|
Full Usage:
this.toArray1D ()
Returns: 'T[]
|
|
Full Usage:
this.toArray2D ()
Returns: 'T[,]
|
|
Full Usage:
this.toArray3D ()
Returns: 'T[,,]
|
|
Full Usage:
this.toArray4D ()
Returns: 'T[,,,]
|
|
|
|
|
|
Full Usage:
this.toBool ()
Returns: bool
|
|
Full Usage:
this.toByte ()
Returns: byte
|
|
Full Usage:
this.toDouble ()
Returns: float
|
|
Full Usage:
this.toImage (?pixelMin, ?pixelMax, ?normalize, ?gridCols)
Parameters:
double
?pixelMax : double
?normalize : bool
?gridCols : int
Returns: Tensor
|
|
Full Usage:
this.toImageString (?pixelMin, ?pixelMax, ?normalize, ?gridCols, ?asciiPalette)
Parameters:
double
?pixelMax : double
?normalize : bool
?gridCols : int
?asciiPalette : string
Returns: string
|
Convert tensor to a grayscale image tensor and return a string representation approximating grayscale values
|
Full Usage:
this.toInt16 ()
Returns: int16
|
|
Full Usage:
this.toInt32 ()
Returns: int
|
|
Full Usage:
this.toInt64 ()
Returns: int64
|
|
Full Usage:
this.toSByte ()
Returns: sbyte
|
|
|
|
Full Usage:
this.toSingle ()
Returns: float32
|
|
|
|
|
|
Full Usage:
this.transpose (dim0, dim1)
Parameters:
int
-
The first dimension to be transposed.
dim1 : int
-
The second dimension to be transposed.
Returns: Tensor
|
Returns a tensor that is a transposed version of input. The given dimensions dim0 and dim1 are swapped.
|
Full Usage:
this.undilate dilations
Parameters:
seq<int>
-
The dilations to use.
Returns: Tensor
|
|
Full Usage:
this.unflatten (dim, unflattenedShape)
Parameters:
int
-
The dimension to unflatten.
unflattenedShape : seq<int>
-
New shape of the unflattened dimenension.
Returns: Tensor
|
|
Full Usage:
this.unsqueeze dim
Parameters:
int
-
The index at which to insert the singleton dimension.
Returns: Tensor
|
|
|
Returns a new tensor with dimensions of size one appended to the end until the number of dimensions is the same as the other tensor.
|
Full Usage:
this.unstack ?dim
Parameters:
int
-
The dimension to remove, defaults to 0.
Returns: Tensor[]
Returns an array of all slices along a given dimension.
|
|
Full Usage:
this.var (dim, ?keepDim, ?unbiased)
Parameters:
int
-
The dimension to reduce.
?keepDim : bool
-
Whether the output tensor has dim retained or not.
?unbiased : bool
-
Whether to use the unbiased estimation or not.
Returns: Tensor
|
If keepdim is True, the output tensor is of the same size as input except in the dimension dim where it is of size 1. Otherwise, dim is squeezed, resulting in the output tensor having 1 fewer dimension(s). If unbiased is False, then the variance will be calculated via the biased estimator. Otherwise, Bessel’s correction will be used.
|
Full Usage:
this.var ?unbiased
Parameters:
bool
-
Whether to use the unbiased estimation or not.
Returns: Tensor
|
If unbiased is False, then the variance will be calculated via the biased estimator. Otherwise, Bessel’s correction will be used.
|
|
The returned tensor shares the same data and must have the same number of elements, but may have a different size. For a tensor to be viewed, the new view size must be compatible with its original size and stride, i.e., each new view dimension must either be a subspace of an original dimension, or only span across original dimensions \(d, d+1, \dots, d+kd,d+1,…,d+k\) that satisfy the following contiguity-like condition that \(\forall i = d, \dots, d+k-1∀i=d,…,d+k−1 ,\) \[\text{stride}[i] = \text{stride}[i+1] \times \text{size}[i+1]\]
|
Full Usage:
this.view shape
Parameters:
seq<int>
-
The desired shape of returned tensor.
Returns: Tensor
|
The returned tensor shares the same data and must have the same number of elements, but may have a different size. For a tensor to be viewed, the new view size must be compatible with its original size and stride, i.e., each new view dimension must either be a subspace of an original dimension, or only span across original dimensions \(d, d+1, \dots, d+kd,d+1,…,d+k\) that satisfy the following contiguity-like condition that \(\forall i = d, \dots, d+k-1∀i=d,…,d+k−1 ,\) \[\text{stride}[i] = \text{stride}[i+1] \times \text{size}[i+1]\]
|
|
The returned tensor shares the same data and must have the same number of elements, but may have a different size. For a tensor to be viewed, the new view size must be compatible with its original size. The returned tensor shares the same data and must have the same number of elements, but may have a different size. For a tensor to be viewed, the new view size must be compatible with its original size and stride, i.e., each new view dimension must either be a subspace of an original dimension, or only span across original dimensions \(d, d+1, \dots, d+kd,d+1,…,d+k\) that satisfy the following contiguity-like condition that \(\forall i = d, \dots, d+k-1∀i=d,…,d+k−1 ,\) \[\text{stride}[i] = \text{stride}[i+1] \times \text{size}[i+1]\]
|
|
Returns a scalar '0' tensor for the given element type and configuration, defaulting to the element type and configuration of the input tensor.
|
|
Returns a new tensor filled with '0' values for the given shape, element type and configuration, defaulting to the shape and configuration of the input tensor.
|
| Static member | Description |
|
|
|
|
|
Multiplies each element of the tensor a by the corresponding element of the tensor b. The resulting tensor is returned. The shapes of the two tensors must be broadcastable.
|
|
|
|
|
|
|
Each element of the tensor a is added to each corresponding element of the tensor b. The resulting tensor is returned. The shapes of the two tensors must be broadcastable.
|
|
|
|
|
Subtracts the scalar b from the corresponding element of the tensor a. The resulting tensor is returned.
|
|
|
Subtracts each element of the tensor b from the corresponding element of the tensor a. The resulting tensor is returned. The shapes of the two tensors must be broadcastable.
|
|
|
|
|
|
|
|
|
Divides each element of the tensor a by the corresponding element of the tensor b. The resulting tensor is returned.  The resulting tensor is returned. The shapes of the two tensors must be broadcastable.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
All tensors must either have the same shape (except in the concatenating dimension) or be empty.
|
Full Usage:
Tensor.create (value, ?device, ?dtype, ?backend)
Parameters:
obj
-
The .NET object used to form the initial values for the tensor.
?device : Device
-
The desired device of returned tensor. Default: if None, uses Device.Default.
?dtype : Dtype
-
The desired element type of returned tensor. Default: if None, uses Dtype.Default.
?backend : Backend
-
The desired backend of returned tensor. Default: if None, uses Backend.Default.
Returns: Tensor
|
The fastest creation technique is a one dimensional array matching the desired dtype. Then use 'view' to reshape.
|
|
|
Full Usage:
Tensor.load (fileName, ?device, ?dtype, ?backend)
Parameters:
string
-
The file from which to load the tensor.
?device : Device
-
The device of the resulting tensor. Defaults to the current default device.
?dtype : Dtype
-
The element type of the resulting tensor. Defaults to the element type of the saved tensor.
?backend : Backend
-
The device of the resulting tensor. Defaults to the current default backend.
Returns: Tensor
|
The backend at the time of saving the tensor must be available when the tensor is reloaded. The tensor is first loaded into that backend and then moved. As a result, intermediate tensors may be created in the process of reloading.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
All tensors need to be of the same shape.
|
© Copyright 2021, DiffSharp Contributors.


The best app that helps you have a faithful devotion to the Rosary of the Virgin Mary
Join the Devotion-Rosary Mailing list
Taking your devotion to the next level. Built for the digital age
This is a longer card with supporting text below as a natural lead-in to additional content. This content is a little bit longer.
This card has supporting text below as a natural lead-in to additional content.
This is a wider card with supporting text below as a natural lead-in to additional content. This card has even longer content than the first to show that equal height action.


Software Engineer Intern
[ More Info ]My first internship was with WeCare Insurance as a Software Engineer Intern, Backend Developer on the Auto Insurance - Web Automation & Web Scraping Team, where I worked remotely due to the ongoing COVID-19 pandemic. I spent the first 3 weeks developing tests and fixing bugs across the company's current software, and the remaining 7 weeks developing software for other insurance carriers. Here's what I put on my resume:
- Developed a web scraping system to automate the retrieval of auto insurance information fromv arious insurance carrieres using Java and Selunium WebDriver
- Utilized MySQL databases to store insurance data and collaborated with other SWE interns to manage database schemas
- Led a team of 4 engineers in testing and optimizing our web automation system
Executive Committee
[ More Info ]Mga Kapatid is a Filipinx American collegiate organization at the University of California, Davis. I served a total of 3 years on the organization's committee. I spent my first year as their Mentorship Coordinator planning and facilitating large-group discussion and activities amongst our Mentor-Mentee Mentorship program. I spent the remaining 2 years on its Executive Committee holding the positions of Secretary and President facilitating community-wide events.
President
- Oversaw a board of 21 individuals, conduct weekly board meetings, and create weekly agendas, using Microsoft/Google suite
- Facilitated events for over 100+ general members throughout the school year, aimed for exploring cultural identity, issues in the Filipinx community, and networking with other members
Secretary
- Oversaw weekly newsletter, organized organization’s archives, maintained a relationship with other Filipinx American student organizations, and facilitated a team of 22 people
Mentorship Coordinator
- Managed a network of over 100+ pairings between mentors and mentees with quarterly events and workshops
- Songs with Friends -
This web application allows users to create a room and invite their friends to form a collaborative Spotify Playlist! It utilizes Spotify's Web API to search and add songs, and connects to the user's playback device.
- BlockChain -
Created a basic BlockChain in Python to develop a deep understanding of this cryptographic tool and its power in today's technologies.
- Implemented a basic Blockchain from scratch in Python using a Proof of Work mining algorithm, validation between all components in the Blockchain, a database serving the blockchain and pending transactions, and utility to publish RSA-signed transactions.
- Built application using Python, the OpenSSL and Requests library, and Flask web framework
- STACK: Python, Flask
- SuperBreakout -
Recreated iconic game in Java and Android Studio with added features such as: falling debris, power-ups and down-grades, and unique levels!


6 references to
System.Management.Automation (6)
engine\MshMemberInfo.cs (2)
3978
public T this[int index] => _members
[
index];
5076
member = _allMembers
[
_currentIndex];
engine\TypeTable.cs (4)
2949
PSMemberInfo member = members
[
i];
3004
PSMemberInfo member = members
[
i];
3020
PSMemberInfo m = members
[
i];
3064
string memberName = members
[
i].Name;


Sharks filmed jumping out of ocean to snatch 30kg mackerel from fishermen
WARNING - GRAPHIC IMAGES: One of the boat's crew was seriously injured while fishing off Cape Carnage in North East Arnhem Land, Australia
by Chiara FiorilloSeveral sharks have been filmed jumping out of the ocean to snatch huge prey caught by fishermen.
Footage posted on social media shows a boat crew hunting for 30kg Spanish mackerel off Cape Carnage in North East Arnhem Land.
The sharks can be seen lunging for their prey in one of Australia's most infested waters.
Fishermen catch the fish with great difficulty as the mackerel jump in the air along with sharks that try to eat them.
Crew members were also filmed holding their catch with huge chunks bitten out of the fish.
One of the boat's crew was seriously injured when a shark smashed into the hull as she was trying to drag a huge mackerel.
Her glove did not protect her from the steel cable used to pull in the fish, leaving her with a deep cut across her whole hand.
The clip, which appeared on the Daily Mail , is part of a documentary by Fishing The Wild .
The video makers were not filming when thirty-year veteran Juanita got injured, but they witnessed and described the terrifying scene.
"She suffered a huge amount of crushed bones and damaged internal structures and required being medically airlifted 700km back to Darwin," they said.
"We were humbled to witness the day-to-day intensity of their lifestyle and to say that these women are tough is the understatement of the century."
Fishing in these remote, shark-infested waters, can be extremely dangerous.
In a previous accident, crew member Prue was stung by a box jellyfish and was rushed to hospital.
Both women are now recovering and will not suffer long-lasting effects from their injuries.
Troy Peterson commented on YouTube: "I can’t imagine a more epic adventure to go on as a fisherman.
"I’ve done a lot of things on and in the water that I thought were wild, but after seeing this incredible footage, I’m not in the same league. Great video!"


The data for these visuals were gathered from the unedited dataset provided by using Visual Basic in Excel. The code used for each the data in the graphs was broken up individual files for organization and can be found here.
This becomes an important question when predicting how much traffic is passing through each station, especially in provinding enough avaliable rides for the demand. Different factors, such as seasons or area, can affect how busy certain areas are. Below, the 5 most popular stations during July 2016 to March 2017 are shown.
The average duartion of rides by month can be found here, but what about the average distance of rides? There is no data labelled for distance ridden and or paths taken, so it is difficult to draw how far each ride travelled. According to this site where the data came from, the duration column was defined as the length of the trip. Additionally, according to here, the average speed of a bike is 12 MPH on a flat surface, as used in Google Maps cycling estimations. For this calculation, the average total distance for each trip was calculated, opposed to the average displacement from the starting station.
The average distance travelled per bike share is 311 miles.
When looking at this value it is important to note that this is per rental verses per use. This means that the distance travelled for a rental could have been the total over the period of up to a year.


Home
Questions
Correct A Question
Users Info
UserID:
Firstname:
lastname:
Phone Number:
Email Address:
Score:
<<
>>
Generate Result


--- layout: template ---
Select an image, then apply a mutation. Each time you apply a mutation a new image is created from the input. Each time you replace a mutation the new image is replaced.


this is a blog about my technical skills and experics i have had during the foundations of the dev academy course. I have made a blog every week to recap my skills so i can look back in the future and understand my thoughts and experices when coming acress these chalanges
my cultrual blog is more about my thoughts thooughtout the foundations course and how my thinking changed thought the weeks. i have uploaded a blog for every week that i was doing to course to get a good idea about how my mindset changed


skip
Syntax
skip
Description
Using skip as an input item in a get statement causes the current input to be skipped until a non-whitespace token is encountered. Whitespace includes all blanks, tabs, form feeds and newlines.
Example
The skip input item was originally intended to be used to see if more input exists in an input file. This use has been largely made redundant by a change in the Turing language. The new version of Turing reads a token, as in get s but not in get s:* or get s:3, and automatically skips any white space following the input value, but will not go beyond the beginning of the next input line. Originally this automatic skipping did not take place, so skip was required. The form of an input loop that used skip was as follows:
loop
get skip % This is line now redundant
exit when eof
get
end loop
Details
The skip bypasses all whitespace characters including any trailing newlines and blank lines. By skipping these characters, a true end-of-file condition was detected. Otherwise, the end-of-file could have been hidden by any whitespace following the last input item. With the change in Turing, the line get skip is no longer needed (although it still works correctly).
Example
The skip can also be used to correctly identify the start of a long string (usually to be read in line or counted mode). Here, it skips the whitespace and trailing newline as follows:
var i : int
var line : string
loop
get i, skip, line:*
end loop
Details
The first item in the get statement reads an integer by skipping all whitespace and reading digits until whitespace is encountered. The input stream is then left with the whitespace as the next input character. The skip then skips past the whitespace, effectively beginning the next input at the next non-whitespace character. This truncates leading blanks and has another, potentially more important, effect. If the integer is the last data on a line and the string is on a following line, the skip is necessary to avoid setting line to a null string value.
See also
get statement and loop statement.