INetworkDefinition¶
-
class
tensorrt.
INetworkDefinition
¶ Represents a TensorRT Network from which the Builder can build an Engine
Variables: - pooling_output_dimensions_formula –
IOutputDimensionsFormula
The formula from computing the pooling output dimensions. If set toNone
, the default formula is used. The default formula in each dimension is \((inputDim + padding * 2 - kernelSize) / stride + 1\) . - convolution_output_dimensions_formula –
IOutputDimensionsFormula
Deprecated Does not currently work reliably and will be removed in a future release. The formula from computing the convolution output dimensions. If set toNone
, the default formula is used. The default formula in each dimension is \((inputDim + padding * 2 - kernelSize) / stride + 1\) . - deconvolution_output_dimensions_formula –
IOutputDimensionsFormula
Deprecated Does not currently work reliably and will be removed in a future release. The formula from computing the deconvolution output dimensions. IfNone
is passed, the default formula is used. The default formula in each dimension is \((inputDim - 1) * stride + kernelSize - 2 * padding\) . - num_layers –
int
The number of layers in the network. - num_inputs –
int
The number of inputs of the network. - num_outputs –
int
The number of outputs of the network. - name –
str
The name of the network. This is used so that it can be associated with a built engine. The name must be at most 128 characters in length. TensorRT makes no use of this string except storing it as part of the engine so that it may be retrieved at runtime. A name unique to the builder will be generated by default. - has_implicit_batch_dimension –
bool
True if tensors have implicit batch dimension. This is a network-wide property. Either all tensors in the network have an implicit batch dimension or none of them do. This is True if and only if this INetworkDefinition was created withcreate_network(dynamic_shapes=True)
. - has_explicit_precision –
bool
True if and only if thisINetworkDefinition
was created withNetworkDefinitionCreationFlag.EXPLICIT_PRECISION
set.
-
__del__
(self: tensorrt.tensorrt.INetworkDefinition) → None¶
-
__exit__
(exc_type, exc_value, traceback)¶ Destroy this object, freeing all memory associated with it. This should be called to ensure that the object is cleaned up properly. Equivalent to invoking
__del__()
-
__getitem__
(self: tensorrt.tensorrt.INetworkDefinition, arg0: int) → tensorrt.tensorrt.ILayer¶
-
__init__
¶ Initialize self. See help(type(self)) for accurate signature.
-
__len__
(self: tensorrt.tensorrt.INetworkDefinition) → int¶
-
add_activation
(self: tensorrt.tensorrt.INetworkDefinition, input: tensorrt.tensorrt.ITensor, type: tensorrt.tensorrt.ActivationType) → tensorrt.tensorrt.IActivationLayer¶ Add an activation layer to the network. See
IActivationLayer
for more information.Parameters: - input – The input tensor to the layer.
- type – The type of activation function to apply.
Returns: The new activation layer, or
None
if it could not be created.
-
add_concatenation
(self: tensorrt.tensorrt.INetworkDefinition, inputs: List[tensorrt.tensorrt.ITensor]) → tensorrt.tensorrt.IConcatenationLayer¶ Add a concatenation layer to the network. Note that all tensors must have the same dimension except for the Channel dimension. See
IConcatenationLayer
for more information.Parameters: inputs – The input tensors to the layer. Returns: The new concatenation layer, or None
if it could not be created.
-
add_constant
(self: tensorrt.tensorrt.INetworkDefinition, shape: tensorrt.tensorrt.Dims, weights: tensorrt.tensorrt.Weights) → tensorrt.tensorrt.IConstantLayer¶ Add a constant layer to the network. See
IConstantLayer
for more information.Parameters: - shape – The shape of the constant.
- weights – The constant value, represented as weights.
Returns: The new constant layer, or
None
if it could not be created.
-
add_convolution
(self: tensorrt.tensorrt.INetworkDefinition, input: tensorrt.tensorrt.ITensor, num_output_maps: int, kernel_shape: tensorrt.tensorrt.DimsHW, kernel: tensorrt.tensorrt.Weights, bias: tensorrt.tensorrt.Weights) → tensorrt.tensorrt.IConvolutionLayer¶ Add a 2D convolution layer to the network. See
IConvolutionLayer
for more information.Parameters: - input – The input tensor to the convolution.
- num_output_maps – The number of output feature maps for the convolution.
- kernel_shape – The dimensions of the convolution kernel.
- kernel – The kernel weights for the convolution.
- bias – The optional bias weights for the convolution.
Returns: The new convolution layer, or
None
if it could not be created.
-
add_convolution_nd
(self: tensorrt.tensorrt.INetworkDefinition, input: tensorrt.tensorrt.ITensor, num_output_maps: int, kernel_shape: tensorrt.tensorrt.Dims, kernel: tensorrt.tensorrt.Weights, bias: tensorrt.tensorrt.Weights) → tensorrt.tensorrt.IConvolutionLayer¶ Add a multi-dimension convolution layer to the network. See
IConvolutionLayer
for more information.Parameters: - input – The input tensor to the convolution.
- num_output_maps – The number of output feature maps for the convolution.
- kernel_shape – The dimensions of the convolution kernel.
- kernel – The kernel weights for the convolution.
- bias – The optional bias weights for the convolution.
Returns: The new convolution layer, or
None
if it could not be created.
-
add_deconvolution
(self: tensorrt.tensorrt.INetworkDefinition, input: tensorrt.tensorrt.ITensor, num_output_maps: int, kernel_shape: tensorrt.tensorrt.DimsHW, kernel: tensorrt.tensorrt.Weights, bias: tensorrt.tensorrt.Weights) → tensorrt.tensorrt.IDeconvolutionLayer¶ Add a 2D deconvolution layer to the network. See
IDeconvolutionLayer
for more information.Parameters: - input – The input tensor to the layer.
- num_output_maps – The number of output feature maps.
- kernel_shape – The dimensions of the convolution kernel.
- kernel – The kernel weights for the convolution.
- bias – The optional bias weights for the convolution.
Returns: The new deconvolution layer, or
None
if it could not be created.
-
add_deconvolution_nd
(self: tensorrt.tensorrt.INetworkDefinition, input: tensorrt.tensorrt.ITensor, num_output_maps: int, kernel_shape: tensorrt.tensorrt.Dims, kernel: tensorrt.tensorrt.Weights, bias: tensorrt.tensorrt.Weights) → tensorrt.tensorrt.IDeconvolutionLayer¶ Add a multi-dimension deconvolution layer to the network. See
IDeconvolutionLayer
for more information.Parameters: - input – The input tensor to the layer.
- num_output_maps – The number of output feature maps.
- kernel_shape – The dimensions of the convolution kernel.
- kernel – The kernel weights for the convolution.
- bias – The optional bias weights for the convolution.
Returns: The new deconvolution layer, or
None
if it could not be created.
-
add_elementwise
(self: tensorrt.tensorrt.INetworkDefinition, input1: tensorrt.tensorrt.ITensor, input2: tensorrt.tensorrt.ITensor, op: tensorrt.tensorrt.ElementWiseOperation) → tensorrt.tensorrt.IElementWiseLayer¶ Add an elementwise layer to the network. See
IElementWiseLayer
for more information.Parameters: - input1 – The first input tensor to the layer.
- input2 – The second input tensor to the layer.
- op – The binary operation that the layer applies.
The input tensors must have the same number of dimensions. For each dimension, their lengths must match, or one of them must be one. In the latter case, the tensor is broadcast along that axis.
The output tensor has the same number of dimensions as the inputs. For each dimension, its length is the maximum of the lengths of the corresponding input dimension.
Returns: The new element-wise layer, or None
if it could not be created.
-
add_fully_connected
(self: tensorrt.tensorrt.INetworkDefinition, input: tensorrt.tensorrt.ITensor, num_outputs: int, kernel: tensorrt.tensorrt.Weights, bias: tensorrt.tensorrt.Weights) → tensorrt.tensorrt.IFullyConnectedLayer¶ Add a fully connected layer to the network. See
IFullyConnectedLayer
for more information.Parameters: - input – The input tensor to the layer.
- num_outputs – The number of outputs of the layer.
- kernel – The kernel weights for the convolution.
- bias – The optional bias weights for the convolution.
Returns: The new fully connected layer, or
None
if it could not be created.
-
add_gather
(self: tensorrt.tensorrt.INetworkDefinition, input: tensorrt.tensorrt.ITensor, indices: tensorrt.tensorrt.ITensor, axis: int) → tensorrt.tensorrt.IGatherLayer¶ Add a pooling layer to the network. See
IGatherLayer
for more information.Parameters: - input – The tensor to gather values from.
- indices – The tensor to get indices from to populate the output tensor.
- axis – The non-batch dimension axis in the data tensor to gather on.
Returns: The new pooling layer, or
None
if it could not be created.
-
add_identity
(self: tensorrt.tensorrt.INetworkDefinition, input: tensorrt.tensorrt.ITensor) → tensorrt.tensorrt.IIdentityLayer¶ Add an identity layer. See
IIdentityLayer
for more information.Parameters: input – The input tensor to the layer. Returns: The new identity layer, or None
if it could not be created.
-
add_input
(self: tensorrt.tensorrt.INetworkDefinition, name: str, dtype: tensorrt.tensorrt.DataType, shape: tensorrt.tensorrt.Dims) → tensorrt.tensorrt.ITensor¶ Adds an input to the network.
Parameters: - name – The name of the tensor.
- dtype – The data type of the tensor. Currently, trt.int8 is not supported for inputs.
- shape – The dimensions of the tensor. The total volume must be less than 2^30 elements.
Returns: The newly added Tensor.
-
add_lrn
(self: tensorrt.tensorrt.INetworkDefinition, input: tensorrt.tensorrt.ITensor, window: int, alpha: float, beta: float, k: float) → tensorrt.tensorrt.ILRNLayer¶ Add a LRN layer to the network. See
ILRNLayer
for more information.Parameters: - input – The input tensor to the layer.
- window – The size of the window.
- alpha – The alpha value for the LRN computation.
- beta – The beta value for the LRN computation.
- k – The k value for the LRN computation.
Returns: The new LRN layer, or
None
if it could not be created.
-
add_matrix_multiply
(self: tensorrt.tensorrt.INetworkDefinition, input0: tensorrt.tensorrt.ITensor, op0: tensorrt.tensorrt.MatrixOperation, input1: tensorrt.tensorrt.ITensor, op1: tensorrt.tensorrt.MatrixOperation) → tensorrt.tensorrt.IMatrixMultiplyLayer¶ Add a matrix multiply layer to the network. See
IMatrixMultiplyLayer
for more information.Parameters: - input0 – The first input tensor (commonly A).
- op0 – Whether to treat input0 as matrices, transposed matrices, or vectors.
- input1 – The second input tensor (commonly B).
- op1 – Whether to treat input1 as matrices, transposed matrices, or vectors.
Returns: The new matrix multiply layer, or
None
if it could not be created.
-
add_matrix_multiply_deprecated
(self: tensorrt.tensorrt.INetworkDefinition, input0: tensorrt.tensorrt.ITensor, transpose0: bool, input1: tensorrt.tensorrt.ITensor, transpose1: bool) → tensorrt.tensorrt.IMatrixMultiplyLayer¶ Add a matrix multiply layer to the network. See
IMatrixMultiplyLayer
for more information.Parameters: - input0 – The first input tensor (commonly A).
- transpose0 – If true, op(input0)=transpose(input0), else op(input0)=input0.
- input1 – The second input tensor (commonly B).
- transpose1 – If true, op(input1)=transpose(input1), else op(input1)=input1.
Returns: The new matrix multiply layer, or
None
if it could not be created.
-
add_padding
(self: tensorrt.tensorrt.INetworkDefinition, input: tensorrt.tensorrt.ITensor, pre_padding: tensorrt.tensorrt.DimsHW, post_padding: tensorrt.tensorrt.DimsHW) → tensorrt.tensorrt.IPaddingLayer¶ Add a padding layer to the network. See
IPaddingLayer
for more information.Parameters: - input – The input tensor to the layer.
- pre_padding – The padding to apply to the start of the tensor.
- post_padding – The padding to apply to the end of the tensor.
Returns: The new padding layer, or
None
if it could not be created.
-
add_parametric_relu
(self: tensorrt.tensorrt.INetworkDefinition, input: tensorrt.tensorrt.ITensor, slopes: tensorrt.tensorrt.ITensor) → tensorrt.tensorrt.IParametricReLULayer¶ Add a parametric ReLU layer. See
IParametricReLULayer
for more information.Parameters: - input – The input tensor to the layer.
- slopes – The slopes tensor (input elements are multiplied with the slopes where the input is negative).
Returns: The new parametric ReLU layer, or
None
if it could not be created.
-
add_plugin
(self: tensorrt.tensorrt.INetworkDefinition, inputs: List[tensorrt.tensorrt.ITensor], plugin: tensorrt.tensorrt.IPlugin) → tensorrt.tensorrt.IPluginLayer¶ Add a plugin layer to the network. See
IPlugin
for more information.Parameters: - inputs – The input tensors to the layer.
- plugin – The layer plugin.
Returns: The new plugin layer, or
None
if it could not be created.
-
add_plugin_ext
(self: tensorrt.tensorrt.INetworkDefinition, inputs: List[tensorrt.tensorrt.ITensor], plugin: tensorrt.tensorrt.IPluginExt) → tensorrt.tensorrt.IPluginLayer¶ Add a plugin layer to the network using an
IPluginExt
interface. SeeIPluginExt
for more information.Parameters: - inputs – The input tensors to the layer.
- plugin – The layer plugin.
Returns: The new plugin layer, or
None
if it could not be created.
-
add_plugin_v2
(self: tensorrt.tensorrt.INetworkDefinition, inputs: List[tensorrt.tensorrt.ITensor], plugin: tensorrt.tensorrt.IPluginV2) → tensorrt.tensorrt.IPluginV2Layer¶ Add a plugin layer to the network using an
IPluginV2
interface. SeeIPluginV2
for more information.Parameters: - inputs – The input tensors to the layer.
- plugin – The layer plugin.
Returns: The new plugin layer, or
None
if it could not be created.
-
add_pooling
(self: tensorrt.tensorrt.INetworkDefinition, input: tensorrt.tensorrt.ITensor, type: tensorrt.tensorrt.PoolingType, window_size: tensorrt.tensorrt.DimsHW) → tensorrt.tensorrt.IPoolingLayer¶ Add a 2D pooling layer to the network. See
IPoolingLayer
for more information.Parameters: - input – The input tensor to the layer.
- type – The type of pooling to apply.
- window_size – The size of the pooling window.
Returns: The new pooling layer, or
None
if it could not be created.
-
add_pooling_nd
(self: tensorrt.tensorrt.INetworkDefinition, input: tensorrt.tensorrt.ITensor, type: tensorrt.tensorrt.PoolingType, window_size: tensorrt.tensorrt.Dims) → tensorrt.tensorrt.IPoolingLayer¶ Add a multi-dimension pooling layer to the network. See
IPoolingLayer
for more information.Parameters: - input – The input tensor to the layer.
- type – The type of pooling to apply.
- window_size – The size of the pooling window.
Returns: The new pooling layer, or
None
if it could not be created.
-
add_ragged_softmax
(self: tensorrt.tensorrt.INetworkDefinition, input: tensorrt.tensorrt.ITensor, bounds: tensorrt.tensorrt.ITensor) → tensorrt.tensorrt.IRaggedSoftMaxLayer¶ Add a ragged softmax layer to the network. See
IRaggedSoftMaxLayer
for more information.Parameters: - input – The ZxS input tensor.
- bounds – The Zx1 bounds tensor.
Returns: The new ragged softmax layer, or
None
if it could not be created.
-
add_reduce
(self: tensorrt.tensorrt.INetworkDefinition, input: tensorrt.tensorrt.ITensor, op: tensorrt.tensorrt.ReduceOperation, axes: int, keep_dims: bool) → tensorrt.tensorrt.IReduceLayer¶ Add a reduce layer to the network. See
IReduceLayer
for more information.Parameters: - input – The input tensor to the layer.
- op – The reduction operation to perform.
- axes –
The reduction dimensions.
Bit 0 of the uint32_t type corresponds to the non-batch dimension 0 boolean and so on.If a bit is set, then the corresponding dimension will be reduced.Let’s say we have an NCHW tensor as input (three non-batch dimensions).Bit 0 corresponds to the C dimension boolean.Bit 1 corresponds to the H dimension boolean.Bit 2 corresponds to the W dimension boolean.Note that reduction is not permitted over the batch size dimension. - keep_dims – The boolean that specifies whether or not to keep the reduced dimensions in the output of the layer.
Returns: The new reduce layer, or
None
if it could not be created.
-
add_resize
(self: tensorrt.tensorrt.INetworkDefinition, input: tensorrt.tensorrt.ITensor) → tensorrt.tensorrt.IResizeLayer¶ Add a resize layer. See
IResizeLayer
for more information.Parameters: input – The input tensor to the layer. Returns: The new resize layer, or None
if it could not be created.
-
add_rnn
(self: tensorrt.tensorrt.INetworkDefinition, input: tensorrt.tensorrt.ITensor, layer_count: int, hidden_size: int, max_seq_length: int, op: tensorrt.tensorrt.RNNOperation, mode: tensorrt.tensorrt.RNNInputMode, direction: tensorrt.tensorrt.RNNDirection, weights: tensorrt.tensorrt.Weights, bias: tensorrt.tensorrt.Weights) → tensorrt.tensorrt.IRNNLayer¶ Add a
layer_count
deep RNN layer to the network with a sequence length ofmax_seq_length
andhidden_size
internal state per layer. SeeIRNNLayer
for more information.Parameters: - input – The input tensor to the layer.
- layer_count – The number of layers in the RNN.
- hidden_size – The size of the internal hidden state for each layer.
- max_seq_length – The maximum length of the time sequence.
- op – The type of RNN to execute.
- mode – The input mode for the RNN.
- direction – The direction to run the RNN.
- weights – The weights for the weight matrix parameters of the RNN.
- bias – The weights for the bias vectors parameters of the RNN.
The input tensors must be of the type
float32
orfloat16
.See
IRNNLayer
for details on the required input format forweights
andbias
.The layout for the
input
tensor should be {1, S_max, N, E}, where:S_max is the maximum allowed sequence length (number of RNN iterations)N is the batch sizeE specifies the embedding length (unlessRNNInputMode.SKIP
is set, in which case it should matchhidden_size
).The first output tensor is the output of the final RNN layer across all timesteps, with dimensions {S_max, N, H}:
S_max is the maximum allowed sequence length (number of RNN iterations)N is the batch sizeH is an output hidden state (equal tohidden_size
or 2xhidden_size
)The second tensor is the final hidden state of the RNN across all layers, and if the RNN is an LSTM (i.e.
op
isRNNOperation.LSTM
), then the third tensor is the final cell state of the RNN across all layers. Both the second and third output tensors have dimensions {L, N, H}:L is equal tonum_layers
if getDirection isRNNDirection.UNIDIRECTION
, and 2*num_layers
if getDirection isRNNDirection.BIDIRECTION
. In the bi-directional case, layer l’s final forward hidden state is stored in L = 2*l, and final backward hidden state is stored in L = 2*l + 1 .N is the batch sizeH ishidden_size
.Note that in bidirectional RNNs, the full “hidden state” for a layer l is the concatenation of its forward hidden state and its backward hidden state, and its size is 2*H.
Deprecated IRNNLayer is superseded by IRNNv2Layer. Use add_rnn_v2() instead.
Returns: The new RNN layer, or None
if it could not be created.
-
add_rnn_v2
(self: tensorrt.tensorrt.INetworkDefinition, input: tensorrt.tensorrt.ITensor, layer_count: int, hidden_size: int, max_seq_length: int, op: tensorrt.tensorrt.RNNOperation) → tensorrt.tensorrt.IRNNv2Layer¶ Add an RNNv2 layer to the network. See
IRNNv2Layer
for more information.Add an
layer_count
deep RNN layer to the network withhidden_size
internal states that can take a batch with fixed or variable sequence lengths.Parameters: - input – The input tensor to the layer (see below).
- layer_count – The number of layers in the RNN.
- hidden_size – Size of the internal hidden state for each layer.
- max_seq_length – Maximum sequence length for the input.
- op – The type of RNN to execute.
By default, the layer is configured with
RNNDirection.UNIDIRECTION
andRNNInputMode.LINEAR
. To change these settings, setIRNNv2Layer.direction
andIRNNv2Layer.input_mode
.Weights and biases for the added layer should be set using
IRNNv2Layer.set_weights_for_gate()
andIRNNv2Layer.set_bias_for_gate()
prior to building an engine using this network.The input tensors must be of the type
float32
orfloat16
. The layout of the weights is row major and must be the same datatype as the input tensor.weights
contain 8 matrices andbias
contains 8 vectors.See
IRNNv2Layer.set_weights_for_gate()
andIRNNv2Layer.set_bias_for_gate()
for details on the required input format forweights
andbias
.The
input
ITensor should contain zero or more index dimensions {N1, …, Np}, followed by two dimensions, defined as follows:S_max is the maximum allowed sequence length (number of RNN iterations)E specifies the embedding length (unlessRNNInputMode.SKIP
is set, in which case it should matchIRNNv2Layer.hidden_size
).By default, all sequences in the input are assumed to be size
max_seq_length
. To provide explicit sequence lengths for each input sequence in the batch, setIRNNv2Layer.seq_lengths
.The RNN layer outputs up to three tensors.
The first output tensor is the output of the final RNN layer across all timesteps, with dimensions {N1, …, Np, S_max, H}:
N1..Np are the index dimensions specified by the input tensorS_max is the maximum allowed sequence length (number of RNN iterations)H is an output hidden state (equal toIRNNv2Layer.hidden_size
or 2xIRNNv2Layer.hidden_size
)The second tensor is the final hidden state of the RNN across all layers, and if the RNN is an LSTM (i.e.
IRNNv2Layer.op
isRNNOperation.LSTM
), then the third tensor is the final cell state of the RNN across all layers. Both the second and third output tensors have dimensions {N1, …, Np, L, H}:N1..Np are the index dimensions specified by the input tensorL is the number of layers in the RNN, equal toIRNNv2Layer.num_layers
H is the hidden state for each layer, equal toIRNNv2Layer.hidden_size
if getDirection isRNNDirection.UNIDIRECTION
, and 2xIRNNv2Layer.hidden_size
otherwise.Returns: The new RNNv2 layer, or None
if it could not be created.
-
add_scale
(self: tensorrt.tensorrt.INetworkDefinition, input: tensorrt.tensorrt.ITensor, mode: tensorrt.tensorrt.ScaleMode, shift: tensorrt.tensorrt.Weights = <tensorrt.tensorrt.Weights object at 0x7f98cb2e8f48>, scale: tensorrt.tensorrt.Weights = <tensorrt.tensorrt.Weights object at 0x7f98cb2e8f10>, power: tensorrt.tensorrt.Weights = <tensorrt.tensorrt.Weights object at 0x7f98cb2e8ed8>) → tensorrt.tensorrt.IScaleLayer¶ Add a scale layer to the network. See
IScaleLayer
for more information.Parameters: - input – The input tensor to the layer. This tensor is required to have a minimum of 3 dimensions.
- mode – The scaling mode.
- shift – The shift value.
- scale – The scale value.
- power – The power value.
If the weights are available, then the size of weights are dependent on the ScaleMode. For UNIFORM, the number of weights is equal to 1. For CHANNEL, the number of weights is equal to the channel dimension. For ELEMENTWISE, the number of weights is equal to the volume of the input.
Returns: The new scale layer, or None
if it could not be created.
-
add_scale_nd
(self: tensorrt.tensorrt.INetworkDefinition, input: tensorrt.tensorrt.ITensor, mode: tensorrt.tensorrt.ScaleMode, shift: tensorrt.tensorrt.Weights = <tensorrt.tensorrt.Weights object at 0x7f98cb2f5030>, scale: tensorrt.tensorrt.Weights = <tensorrt.tensorrt.Weights object at 0x7f98cb2e8fb8>, power: tensorrt.tensorrt.Weights = <tensorrt.tensorrt.Weights object at 0x7f98cb2e8f80>, channel_axis: int) → tensorrt.tensorrt.IScaleLayer¶ Add a multi-dimension scale layer to the network. See
IScaleLayer
for more information.Parameters: - input – The input tensor to the layer. This tensor is required to have a minimum of 3 dimensions.
- mode – The scaling mode.
- shift – The shift value.
- scale – The scale value.
- power – The power value.
- channel_axis – The channel dimension axis.
If the weights are available, then the size of weights are dependent on the ScaleMode. For UNIFORM, the number of weights is equal to 1. For CHANNEL, the number of weights is equal to the channel dimension. For ELEMENTWISE, the number of weights is equal to the volume of the input.
Returns: The new scale layer, or None
if it could not be created.
-
add_shape
(self: tensorrt.tensorrt.INetworkDefinition, input: tensorrt.tensorrt.ITensor) → tensorrt.tensorrt.IShapeLayer¶ Add a shape layer to the network. See
IShapeLayer
for more information.Parameters: input – The input tensor to the layer. Returns: The new shape layer, or None
if it could not be created.
-
add_shuffle
(self: tensorrt.tensorrt.INetworkDefinition, input: tensorrt.tensorrt.ITensor) → tensorrt.tensorrt.IShuffleLayer¶ Add a shuffle layer to the network. See
IShuffleLayer
for more information.Parameters: input – The input tensor to the layer. Returns: The new shuffle layer, or None
if it could not be created.
-
add_slice
(self: tensorrt.tensorrt.INetworkDefinition, input: tensorrt.tensorrt.ITensor, start: tensorrt.tensorrt.Dims, shape: tensorrt.tensorrt.Dims, stride: tensorrt.tensorrt.Dims) → tensorrt.tensorrt.ISliceLayer¶ Add a slice layer to the network. See
ISliceLayer
for more information.Parameters: - input – The input tensor to the layer.
- start – The start offset.
- shape – The output shape.
- stride – The slicing stride. Positive, negative, zero stride values, and combinations of them in different dimensions are allowed.
Returns: The new slice layer, or
None
if it could not be created.
-
add_softmax
(self: tensorrt.tensorrt.INetworkDefinition, input: tensorrt.tensorrt.ITensor) → tensorrt.tensorrt.ISoftMaxLayer¶ Add a softmax layer to the network. See
ISoftMaxLayer
for more information.Parameters: input – The input tensor to the layer. Returns: The new softmax layer, or None
if it could not be created.
-
add_topk
(self: tensorrt.tensorrt.INetworkDefinition, input: tensorrt.tensorrt.ITensor, op: tensorrt.tensorrt.TopKOperation, k: int, axes: int) → tensorrt.tensorrt.ITopKLayer¶ Add a TopK layer to the network. See
ITopKLayer
for more information.The TopK layer has two outputs of the same dimensions. The first contains data values, the second contains index positions for the values. Output values are sorted, largest first for operation
TopKOperation.MAX
and smallest first for operationTopKOperation.MIN
.Currently only values of K up to 1024 are supported.
Parameters: - input – The input tensor to the layer.
- op – Operation to perform.
- k – Number of elements to keep.
- axes – The reduction dimensions. Bit 0 of the uint32_t type corresponds to the non-batch dimension 0 boolean and so on. If a bit is set, then the corresponding dimension will be reduced. Let’s say we have an NCHW tensor as input (three non-batch dimensions). Bit 0 corresponds to the C dimension boolean. Bit 1 corresponds to the H dimension boolean. Bit 2 corresponds to the W dimension boolean. Note that TopK reduction is currently only permitted over one dimension.
Returns: The new TopK layer, or
None
if it could not be created.
-
add_unary
(self: tensorrt.tensorrt.INetworkDefinition, input: tensorrt.tensorrt.ITensor, op: tensorrt.tensorrt.UnaryOperation) → tensorrt.tensorrt.IUnaryLayer¶ Add a unary layer to the network. See
IUnaryLayer
for more information.Parameters: - input – The input tensor to the layer.
- op – The operation to apply.
Returns: The new unary layer, or
None
if it could not be created.
-
get_input
(self: tensorrt.tensorrt.INetworkDefinition, index: int) → tensorrt.tensorrt.ITensor¶ Get the input tensor specified by the given index.
Parameters: index – The index of the input tensor. Returns: The tensor, or None
if it is out of range.
-
get_layer
(self: tensorrt.tensorrt.INetworkDefinition, index: int) → tensorrt.tensorrt.ILayer¶ Get the layer specified by the given index.
Parameters: index – The index of the layer. Returns: The layer, or None
if it is out of range.
-
get_output
(self: tensorrt.tensorrt.INetworkDefinition, index: int) → tensorrt.tensorrt.ITensor¶ Get the output tensor specified by the given index.
Parameters: index – The index of the output tensor. Returns: The tensor, or None
if it is out of range.
-
mark_output
(self: tensorrt.tensorrt.INetworkDefinition, tensor: tensorrt.tensorrt.ITensor) → None¶ Mark a tensor as an output.
Parameters: tensor – The tensor to mark.
-
mark_output_for_shapes
(self: tensorrt.tensorrt.INetworkDefinition, tensor: tensorrt.tensorrt.ITensor) → bool¶ Enable tensor’s value to be computed by
IExecutionContext.get_shape_binding()
.Parameters: tensor – The tensor to unmark as an output tensor. The tensor must be of type tensorrt.int32
and have no more than one dimension.Returns: True
if successful,False
if tensor is already marked as an output.
-
remove_tensor
(self: tensorrt.tensorrt.INetworkDefinition, tensor: tensorrt.tensorrt.ITensor) → None¶ Remove a tensor from the network.
Parameters: tensor – The tensor to remove It is illegal to remove a tensor that is the input or output of a layer. if this method is called with such a tensor, a warning will be emitted on the log and the call will be ignored.
-
unmark_output
(self: tensorrt.tensorrt.INetworkDefinition, tensor: tensorrt.tensorrt.ITensor) → None¶ Unmark a tensor as a network output.
Parameters: tensor – The tensor to unmark as an output tensor.
-
unmark_output_for_shapes
(self: tensorrt.tensorrt.INetworkDefinition, tensor: tensorrt.tensorrt.ITensor) → bool¶ Undo
mark_output_for_shapes()
.Parameters: tensor – The tensor to unmark as an output tensor. Returns: True
if successful,False
if tensor is not marked as an output.
- pooling_output_dimensions_formula –


Ohh so crazy. Yeah so crazy. Combining that much with a bottle of whiskey is equal to commiting suicide. I did this not because I didn't know this I knew this well but I did this because I just wanted to DO.
I was alone in France. (I live in Turkey but I went a vacation to France) I was so bored because I dont know French and I can not commucinate well with French girls even I speak superior English :). This made me drink everyday and I brought 50 - 1mg Xanax tabs with me because I was depressed sometime a few months ago and the doc prescribed them.
I saved some of the tabs and wanted to combine them with alc. just to see the effects. I started drinking whiskey and when I came to the half of the bottle I popped 8 tabs of Xanax at once (the side effects didnt even come to my mind). Then after 1 hr I started to feel ultra Euphoric. I was light and heavy at the same time.
I laid to the carpets and started to roll. I was eating the carpets. My friends said that I was saying very strange things at the same time and laughing. I can't remember the experience very much because I was blacked out by combinining that much benzodiazepine w/ alc. They took me to billiards then to a bar to dirnk a coke. But I can only remember 2-3 scenes of these places. I was totally blacked out. They said that I went to bed at 2 o'clock and I woke up at 15. Whooa.! I slept for 13 hours not waking even once.! When I woke up I was totally dehydrated and I wanted to urinate. I would nearly explode. I urinated for a minute and then drank a great amount of water (3 lt) in 10 minutes. Then I went to bed and slept for another 5 hours.  It was 20:00 and all my day was wasted by sleeping. I was so sad.
So in conclusion I can say that I can only remember the start of the experience (40-50 min) being ultra euphoric but the rest is blacked out.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


FreeSASA Demo
This application requires browser support for Javascript (ES6) and WebAssembly
PDB code
Calculate
Loading FreeSASA ...


{% include head.html %}
{% include navbar.html %}
{% include contact_form.html %}
{% include footer.html %} {% include footer_scripts.html %} {% include google_maps_script.html %}


The following are a few of my first proper salvia trip reports. Up until this point I'd only ever tried the normal leaf, and found the effects barely noticable, and a couple of times I'd tried utilising the quid method, which also proved unsucessful, even at 5 grams.
Having had no luck with all previous experiences of non-fortified leaf, I decided to really go for it and see whether I was screwing up somewhere along the line or just hard-headed. I measured out 1/20th of a gram of 5X extract and loaded it into a medium-sized bong, and took it all down in one hit. There was really no anticipation or fear. Looking back, I don't think I was expecting anything to happen - I'd never had any luck with the plant before.
The next thing I know, I'm shifting the bong away from the vicinity of my feet and then *poof* - gone. I have no recollection of the next ten or so seconds, but when I did regain consciousness my head seemed to be part of the wheel of an old stone watermill. The whole situation was immensely strange; for a few seconds I actually *was* the wheel. I was not a human being, in the sense that I had the ability to appreciate and philosophise about existence. I had absolutely no control over my faculties. It was like I was posessed, bound by duty, in this case, the laws of physics, to carry out my task, which was to spin around. The strangest thing was the physical effect it had on me: I was rolling my head around like you would when warming up for the gym.
After a few seconds I realised that it was the salvia that was causing all this, but try as I might I could not stop my head from being pulled in a circle. I also now felt the presence of maybe some kind of leprechaun creatures off to my left. They were definately clad in green attire, that I was sure of. In fact, everything had a greenish tint to it. I later realised this was probably because my walls are painted green. Pretty obvious, I know, but then you tend not to notice things like that at the time.
I think I loaded up another bowl (I was quite heady), but I do remember at some point staring at the carpet and seeing two-dimensional patterns morphing into things like the outlines of faces. They had a quality more like sand being disturbed from underneath. Also, the music playing, a combination of gentle fluting and gregorian chanting, seemed deeply profound. I can't really explain it, but it was as if the musicians were observing me from far away.
Overall, all I could conclude was that S.D. was incredibly strange. I can't honestly say I gained anything from the experience, but it wasn't unpleasant either. Overall, on the S-A-L-V-I-A scale I would probably have it down as a Level 3.
The next time I tried salvia it was again in my room. I was determined to try and make some sense out of the experience this time, and maybe because of that it was rather uneventful. I had this strange feeling of resistance against any attempts to 'figure it all out', and found myself becoming a tad frustrated at my head's tendency to start drifting off into a circle again. I'd stop myself from doing it, but it always found a way of beating me - I remember distinctly thinking 'Oh, what's that on the floor over there to my left? And on the roof up there? And now to my right - hey, I'm spinning again!' Not really an inspiring experience.
This annoyed me slightly. The first time it was a novelty, but if all I was going to get out of salvia was neckache then what was the point? Not one to give up, I later went over to a friend's house to introduce him to Sally D, and to see if he would suffer the same bizarre phenomenon. He said it just made him feel really heavy, and laughed heartily at apparently nothing for a short while. I was feeling very relaxed by now, so I decided to up the dosage for my hit - nothing excessive, just an incremental increase. I held the smoke in for longer this time, and only vaguely remember exhaling, before muttering something like 'I'm going, just lie down on a jacket' and rolling flat on the floor.
And then I'm there again. I have no ego, no concept of the outside world, and although I am aware of the room I am in, it is irrelevant: all I am focused on is this huge wooden wheel - either of a horse-drawn cart or a carriage of some sort. The leprechauns are driving it (I can't see them though), and I am caught up amongst the spokes and being pulled along, left to right, as always. I very briefly lapse out of this. That's something I find very disconcerting about salvia. You can be utterly gone one second and then back the next, with just enough time realise that you're tripping, before having your attention dragged back to whatever it was you were preoccupied with before. I can see splodgy green prints on the floor from where the cart has been. I wouldn't exactly call it a hallucination.  Nothing concrete.
I won't bore you with more of the same, but I will say that the last time I smoked S.D. It was a rather unpleasant experience - the 'wheel' apparently grows in size each time I enter its world. This time it was at least as tall as my room, and I felt overwhelmed. I managed to resist being dragged across the floor and escaped for some fresh air, where I nearly began rolling about in the street. I was freaked out by the lack of control I had over the situation and how it could have ended up, and I haven't tried salvia since, although this is for 'financial reasons', or being skint, really.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


| 003:118 Khan | : |
O you who believe! Take not as (your) Bitanah (advisors, consultants, protectors, helpers, friends, etc.) those outside your religion (pagans, Jews, Christians, and hypocrites) since they will not fail to do their best to corrupt you. They desire to harm you severely. Hatred has already appeared from their mouths, but what their breasts conceal is far worse. Indeed We have made plain to you the Ayat (proofs, evidences, verses) if you understand. |
| 003:118 Maulana | : |
O you who believe, take not for intimate friends others than your own people: they spare no pains to cause you loss. They love that which distresses you. Vehement hatred has already appeared from out of their mouths, and that which their hearts conceal is greater still. Indeed We have made the messages clear to you, if you understand. |
| 003:118 Pickthal | : |
O ye who believe!  Hatred is revealed by (the utterance of) their mouths, but that which their breasts hide is greater. We have made plain for you the revelations if ye will understand. |
| 003:118 Rashad | : |
O you who believe, do not befriend outsiders who never cease to wish you harm; they even wish to see you suffer. Hatred flows out of their mouths and what they hide in their chests is far worse. We thus clarify the revelations for you, if you understand. |
| 003:118 Sarwar | : |
Believers, do not expose your privacy to the unbelievers. They like to mislead you and see that you are seriously harmed. Signs of animosity from their mouths have already become audible, but what they hide in their heads is even worse. We have certainly made Our evidence clear, if only you would consider it. |
| 003:118 Shakir | : |
O you who believe! do not take for intimate friends from among others than your own people; they do not fall short of inflicting loss upon you; they love what distresses you; vehement hatred has already appeared from out of their mouths, and what their breasts conceal is greater still; indeed, We have made the communications clear to you, if you will understand. |
| 003:118 Sherali | : |
O ye who believe ! take not others than your own people as intimate friends; they will spare no pains to ruin you. They love to see you in trouble. Hatred has already shown itself through the utterances of their mouths and what their breasts hide is greater still. We have made clear to you OUR commandments, if you will only use your understanding. |
| 003:118 Yusufali | : |
O ye who believe!   We have made plain to you the Signs, if ye have wisdom. |
Concepts/Themes Covered: أركان الإسلام > التوحيد > الكافرون > صفات الكفار Pillars of Islam> Islamic> The Disbelievers> The Characteristics of the Disbelievers أركان الإسلام > التوحيد > الكافرون > النهي عن موالاة الكفار Pillars of Islam> Islamic> The Disbelievers> The Prohibition to Follow the Atheists الإيمان > الإيمان بالله > النفاق Faith> Belief In Allah> Hypocrisy الإنسان والعلاقات الأخلاقية > الأخلاق الحميدة > المودة Man and The Moral Relations> Good Morals>Intimacy الإنسان والعلاقات الاجتماعية > المجتمع > المودة Man and The Social Relations>The Society>Intimacy
This tool uses eight English parallel translations for the Holy Quran imported from Mr. Clay Smith. You can also visit Qurany Concepts for browsing the Quran themes or topics. If you want to search the Holy Quran for keywords, please visit Qurany Keywords.


Reproducible Research Resources
It should be obvious why reproducible research (RR) is preferred to non-reproducible research. Googling "reproducible research" should provide all the details. Needless to say, most published research data analyses are very difficult to reproduce and hence the results of these analyses can easily be called into question. A simple remedy is to do all research in a reproducible manner, from the very beginning with the exploratory analyses.
Dynamic report generation and (distributed) version control can help! Hence, we consider knitr and GitHub below.
knitr, the dynamic report generation engine for R
- Review of knitr
- knitr examples
- For non-PDFLaTeX output like .html or .docx, try using R Markdown (.Rmd) as it is quite easy to implement
- knitr can be used with LaTeX slides and posters, in the same way as LaTeX documents
- Figures and plots are easy with knitr
- Formatted tables, not so much, but we can work on that
Why use version control?
If you have ever ...
- changed your code, then sometime later, wanted to revert back to your old code
- had to develop multiple versions of your code
- wanted to merge a new feature into a different version of your code
- lost the code backup you needed
- wanted to test a new feature without messing with your working code
- been distracted by too much commented code that you kept "just in case"
- been frustrated by the logistics of collaborative writing (either code or documents)
If you have, then version control can help, especially if you code a lot.
Why use GitHub for version control?
Not only is GitHub multiplatform (Linux, Mac, Windows) and open source, but users clone (copy) the entire repository (project), so working offline is easy. Plus, it appears that GitHub is currently (2014) the most popular version control platform (with commits to the cloud), so collaborating with others should be relatively easy with GitHub.
Plus GitHub should handle any text-based file format well, whether that is .R, .tex, .Rnw, .Rmd, .md, .sh, .cpp, .py, etc.
No private repositories are possible with a standard free GitHub account, so please apply for an educational discount after signing in with your University email address. Your account should be upgraded to a free Micro account for the next two years, which means up to 5 private repositories. If 5 private repositories per user is insufficient, then instead of GitHub, we can consider using Bitbucket, which has an "unlimited academic plan".
Is Git different from GitHub?
Good question. Yes, GitHub is different from Git. To simply explain the difference, Git is a command-line version control tool that can work on a local computer without the use of the internet. Git is the software system that GitHub works on. GitHub hosts online Git repositories and provides a web-based GUI so that multiple users can easily collaborate on repositories.
Please try the following tutorials to get more familiar with both Git and GitHub. Many GitHub tutorials give much more detail than is necessary, so I thought that we could distill the GitHub tasks, which are most important to our lab, into these few tutorials. Yes, there will be a learning curve, but using version control for research will (probably) save time in the long run.
GitHub "Hello, world!" Tutorial
Let's use the GitHub GUI to start a simple repository.
- Create a GitHub user account at github.com.
- Once logged in, click the "+" (plus) sign in the top right-hand corner, and select "New repository".
- Name the repository "helloworld", select "Initialize this repository with a README" and select "Create Repository".
- Click on the README.md link and then on the pencil icon to edit README.md.
- Write in "Hello, world!" on the third line, then click "Commit changes" at the bottom.
- The file should be updated with your text. You can even turn your README.md file into a website by following the directions at the GitHub Pages site.
GitHub Pull Request Tutorial
"Pull request" means that you want to collaborate on someone else's repository, so you download ("fork") their repository, make some changes to it, then submit it back to them ("pull request"), so that they can consider accepting your changes. As an example, let's use the README.md file which is the basis for this webpage.
- Install
git
on your computer and set the global user name and user email with the following example terminal commands:$ git config --global user.name "GitHub_username"
, then$ git config --global user.email<EMAIL_ADDRESS>. - Sign in to GitHub, if not already signed in, and go to the GitHub repository for this page: https://github.com/cui-lab/cui-lab.github.io.
- Click the "Fork" button, to fork your own copy of the cui-lab.github.io repository to your account.
- Copy the HTTPS clone URL (notated by
HTTPS_clone_URL
) on the right side of the page. - In the terminal, change directory into your preferred working directory and input the command:
$ git clone HTTPS_clone_URL
. - Change directory into cui-lab.github.io and then make, and save, some changes to README.md.
- Add the README.md file to the index to prepare for the next commit using the command:
$ git add README.md
. - Commit and comment (in quotes, after the
-m
option) on your commit using the example command:$ git commit -m "made a few changes"
. - Push the committed file(s) to your GitHub repository using the following command and then inputing your username and password:
$ git push
. - You should then see the changes on the cloned repository on your account. If you would like to submit your changes to the original owner of the cloned repository, then on the page for your cloned repository, click on the "Pull Requests" and create a new pull request. The owner will check your pull request and decide whether to accept and merge your changes.
GitHub SSH Key Tutorial
Use an SSH key if you don't want to have to input your username and password each time you git push
.
- Assuming you have a GitHub account and git is installed on your computer, change directory to ~/.ssh and check to see if you already have a public RSA key. If you do, skip steps 2-4.
- Generate an SSH key with the command:
$ ssh-keygen -t rsa
. - Upon the question, "Enter file in which to save the key (/home/user/.ssh/id_rsa):", use something like "user_id_rsa", but replace the "user" part.
- Do not enter a passphrase.
- After logging in to GitHub, open Settings > SSH keys > Add SSH key.
- The public key can be copied from
$ cat user_id_rsa.pub
and pasted in the "Key" space. After adding a title, for instance the name of the computer, click on Add key. - Verify that the SSH key was correctly set up by using this terminal command:
$ ssh -T<EMAIL_ADDRESS>. Hopefully the output states something like:Hi! You've successfully authenticated, but GitHub does not provide shell access.
If not, then follow the given instructions, or Google the output for help online. - Start an new GitHub repository named "test".
- Make a new directory for your repository, on your local computer, and change directory into this directory.
- Use the following commands, making sure to replace
GitHub_username
with your GitHub username:$ git init
, then$ git remote add origin git@github.com:GitHub_username/test.git
and then$ git remote -v
. The output should be:origin git@github.com:GitHub_username/test.git (fetch)
andorigin git@github.com:GitHub_username/test.git (push)
. - Create a README.txt text file in your repository's directory, then use the following commands:
$ git add README.txt
, then$ git commit -m "some comment about the commit"
and then$ git push origin master
. Theorigin master
part indicates that we are pushing into the repository named "origin", and specifically the "master" branch of "origin". Unlike in the previous tutorial, you will not need to input your GitHub username and password. - The README.txt should appear on the GitHub website. Make some changes to this file using the GitHub website and commit the changes to the master branch.
- Pull the changed README.txt file into your local directory using the following terminal command:
$ git pull origin master
. - Check to see that the local file has the most recent changes. Then make other changes with your local computer and use the commands in step 11 to see the changes reflected in the online GitHub repository.
More on Branching and Merging
Until a simplified tutorial on this is written, allow Google to be your teacher.


Throughout my career, I have been able to gain extensive experience within the mobile advertising and cryptocurrency spaces. In July 2017, I moved to Reno to align my lifestyle with my passion for the outdoors. I am looking forward to taking advantage of the opportunities presented.


<ywlib>
is a low-pollutive integrated C++ library.
You can use <ywlib>
with any other libraries only if they don't use namespace yw
.
Moreover, you need no additional predefined macros for <ywlib>
.
I'm sorry to say that, however, <ywlib>
is now constructing.
Only a few functions, typenames, constants, concepts are available.
Latest version of <ywlib>
is v0.1
Almost all the contents are constant-evaluable.
<type.hpp>
,
<concept.hpp>
,
<utility.hpp>
,
<array.hpp>
,
<math.hpp>
There are useful functions, for example dynamic-array, string, in/outputs, etc..
<darray.hpp>
,


Duplicate
Delete
Got bugs!
New/Clear
Report
Load
Eval
File to load:
messages go here
Inputs:
Output:


Press n or j to go to the next uncovered block, b, p or k for the previous block.
| File | Statements | Branches | Functions | Lines | |||||
|---|---|---|---|---|---|---|---|---|---|
| data-set.ts |
|
87.5% | 14/16 | 100% | 0/0 | 60% | 3/5 | 87.5% | 14/16 |
| field.ts |
|
80% | 8/10 | 100% | 0/0 | 50% | 2/4 | 80% | 8/10 |
| index.ts |
|
84.62% | 11/13 | 100% | 0/0 | 60% | 3/5 | 100% | 8/8 |
| query.ts |
|
94.34% | 50/53 | 76.47% | 13/17 | 100% | 11/11 | 94.12% | 48/51 |


This book will challenge you to learn and understand the most obscure and tricky parts of Javascript.
In order to perform the best that you can I recommend you not to cheat taking a look at solutions before you suggest one.
This book can be used as a learning resource for Javascript training if you want, but please send a tweet recommending us to other people.
I hope you enjoy this book because this is the purpose of this book.
Feedback is welcome.
Thanks a lot to GITBOOK team for it’s amazing project to write your own books using Github repos.


If you haven’t read about this hack already, take 20 minutes out of your day and read through the article attached below. While the importance of complex passwords, separating your accounts and more can’t be over-stated, there some simple things you should do right away, for example:
- Enable two-factor authentication in Gmail so that accessing it requires two items — your password and a one-time code — to make it tougher to get in.
- Facebook has a few security settings that you should make use of. Spend a few minutes, clear out unknown sessions and devices, and enable notifications when your account is accessed on an unknown computer/device.
- Don’t ‘daisy chain’ your critical accounts — ie, prevent making two very active accounts the recovery/backup account for each other.
- This one is for everyone that has asked me for this advice over the last 5 years — no, don’t click on a link or open an attachment to something you do not know or understand. If it was really important, the person will find a way to make sure you see it.
The article is a worth read to understand sometimes how simple it is to get access to your life. Don’t get me wrong, I’m a big advocate of the web in terms of function, use and all that pretty stuff. But everything has its cons so let’s not be careless about it.
To the experts, I say we really need to look at some standardization. The line — ’[t]he very four digits that Amazon considers unimportant enough to display in the clear on the Web are precisely the same ones that Apple considers secure enough to perform identity verification’ — concerns me deeply.
Meet Mat Honan. He just had his digital life dissolved by hackers. Photo: Ariel Zambelich/Wired. Illustration: Ross Patton/Wired
In the space of one hour, my entire digital life was destroyed. First my Google account was taken over, then deleted.  And worst of all, my AppleID account was broken into, and my hackers used it to remotely erase all of the data on my iPhone, iPad, and MacBook.
…
But what happened to me exposes vital security flaws in several customer service systems, most notably Apple’s and Amazon’s. Apple tech support gave the hackers access to my iCloud account. Amazon tech support gave them the ability to see a piece of information — a partial credit card number — that Apple used to release information. In short, the very four digits that Amazon considers unimportant enough to display in the clear on the web are precisely the same ones that Apple considers secure enough to perform identity verification. The disconnect exposes flaws in data management policies endemic to the entire technology industry, and points to a looming nightmare as we enter the era of cloud computing and connected devices.


{% extends base_template %} {% load staticfiles %} {% block title %}Donate{% endblock title %} {% block donate_nav %}selected{% endblock donate_nav %} {% block headcss %} {{ block.super }} {% endblock headcss %} {% block headjs %} {{ block.super }} {% endblock headjs %} {% block bodycontents %}
We believe that education is both the key to breaking the cycle of poverty and opening the door to human flourishing. With your support, we're one step closer to making universal education a reality!


Thank you for making such a good extension - it transformed Battlelog into something useful :)
I'm currently in the process of service starring all weapons on BF4, and I was wondering if you could update the filters available on the Stats > Weapons page?
Currently, unless you either select the "All" filter or search directly, launchers like the RPG/SMAW don't exist in any of the current filters.
Could you add some new filters and extend some current ones?
Gadgets (extend to include - Defibrillator, Repair Tool, Ballistic Shield)
Launchers (new filter to include all Engineer portable launchers)
Underslung (new filter to include all underslung variants M26/M320)
*Battle Pickups (new filter to include all battlepickups - M32 MGL, HVM-II, M136-CS, AMR-2 all variants, M2A83 all variants, Rorsch)
If it is possible, then can I also suggest removing the current Battle Pickup snipers/shotguns from their respective current filters too?
*Edited to include Battle Pickup Snipers
Post edited 1 x times, last by
BrainFooLong
Administrator
BrainFooLong
Administrator
Sorry for late response.
The filters are taken directly from the battlelog weapon groups, we just make it available for filter.
If they don't have those things properly included than it's a pain, but we can't fix this unless we rewrite the whole filter system, which we will not do.


Our independent mobile mechanics go exactly where you are, immediately. You don’t need to move.
Getting your car fixed never was so relaxed. Our shops have insurance coverages.
Enjoy 12 month or 12,000 miles warranty on many services.
No schedule, work when you’re available!
Double your earnings. Try it!
We’ll do the advertising if you do the work. Relax, bringing mechanics and clients together is our job.


Competencies (Measurable Characteristics)
Recommendation, 2007 April 15
Editor:
Chuck Allen, HR-XML
Contributors:
Naomi Bloom, Bloom & Wallace; Dan Bork, iXmatch; Paul Kiel, HR-XML; David Scott, J.D. Edwards; David Cohn, Burning Glass, Inc.; Kim Bartkus, HR-XML; Robert Mickley, Gazebo Software; Enrique Kortright, DOD; Jason Weiss, DDI; Kathi Dolan, Manpower
Copyright © 2007 HR-XML Consortium, Inc..
Abstract
This document describes HR-XML’s competencies schemas. The competencies schema allows the capture of information about evidence used to substantiate a competency and ratings and weights that can be used to rank, compare, and otherwise evaluate of the sufficiency or desirability of a competency.
This schema is intended as a fragment or module that would be incorporated within broader process-specific schema. The competencies schema is particularly relevant to processes involving the rating, measuring, comparing, or matching an asserted competency (for example, a skill claimed in a resume) against one that is demanded (for example, a skill required in a job description or requisition).
Table of Contents
1.3.2 Items Outside of Design Scope
2 Supported Business Processes
4 Implementation Considerations
5 Appendix A - Document Version History
6 Appendix B – Related Documents
7 Appendix C – Reference Examples
7.1 Competency with Years of Experience and Test Score
7.2 License as Competency Evidence. 18
7.3 Education as Competency Evidence
7.4 Recursive Competencies: Communication Skills
7.5 Describing Language Skills
7.6 Direct Observation as Competency Evidence
7.7.1 Skills: Reading Comprehension
7.7.2 Abilities: Oral Comprehension
7.7.4 Work Activities: Performing Administrative Activities
7.7.5 Clerical: Example Combining O*Net With Privately Defined Measure
The objective of this project is the creation of an XML schema to provide trading partners standardized and practical means to exchange information about competencies within a variety of business contexts.
The competency schema delivered by this workgroup is intended as a fragment that will be used within broader, process-specific schema developed by the HR-XML Consortium and other organizations.
Within the Competency.xsd schema, an optional interval
attribute has been added to the NumericValue element within CompetencyEvidence
and CompetencyWeight (see Sections 3.2, CompetencyEvidence and 3.2.1,
CompetencyWeight). The interval attribute is used to specify the scale
increment or step when such information is necessary or useful for comparisons
or calculations.
Example: The Test of Written English® is scored on a six-point scale
rounded to the nearest half-point increment. The highest possible score is 6
(maxValue=”6”). The lowest is 0 (minValue=”0”). The
increment is “.5” (i.e., interval=“.5”). Thus, valid
scores are 6.0, 5.5, 5.0, 4.5, 4.0, 3.5, 3.0, 2.5, 2.0, 1.5, 1, and 0.
One of the challenges in creating a standard schema for the exchange of competency information is the many ways that the term “competency” has been used by different people at different points in time within disciplines such as human resource management, organizational theory, behavioral science, industrial psychology, and education.
One of the HR-XML Competency Workgroup’s important design goals was the development of a competency schema that would be relatively simple and sufficiently flexible to be useful within a variety of business contexts. Towards this end, HR-XML’s Competency Workgroup wanted to avoid binding its schema to a definition of competency that would require difficult distinctions, such as the differences between “innate” and “learned” characteristics. Likewise, the workgroup did not want to bind the schema to a definition of competency that would limit the schema’s usefulness in capturing and exchanging information about behaviorally revealed competencies versus those competencies evidenced by assessments, certificates, or degrees.
In exploring the appropriate scope for the competencies schema, one of the concepts considered by the workgroup was “KASOCs,” as defined in Bloom & Wallace’s HRM Business Model "Starter Kit.” KASOC is an acronym for Knowledge, Skills, Abilities, and Other Characteristics. The concept of KASOC was specifically developed as a generalized and flexible descriptor for the type of measurable, performance-related characteristics that are important to numerous HR management processes. The KASOC concept was the basis for the following definition of competency adopted by the Workgroup:
Competency. A specific, identifiable, definable, and measurable knowledge, skill, ability and/or other deployment-related characteristic (e.g. attitude, behavior, physical ability) which a human resource may possess and which is necessary for, or material to, the performance of an activity within a specific business context.
Additional elaboration is required to understand some portions of this definition:
§ Competencies are related to performing an activity. Competencies can be thought of as a level of ability or characteristic useful or necessary to performing an activity.
§ Competencies may include deployment-related characteristics such as "willing to relocate," "non-smoker," etc., but generally would not include purely demographic characteristics, such sex, race, or religion.
NOTE: While the workgroup’s definition of competencies is based on the concept of KASOCs, the term competency was chosen over KASOCs because it was deemed to be more meaningful to a wider audience. Moreover, the acronym KASOC was not considered be appropriate based on the element naming conventions outlined in the HR-XML Consortium’s Schema Design Guidelines.
The concept of competency pervades HR management processes. Competencies are not merely descriptors of an employee, position, organizational work unit, or training resource; they are the glue that holds together major HR management activities. It is difficult to discuss any major HR management process without the concept of competencies.[1]
The HR-XML Consortium’s competencies schema is designed as a reusable schema fragment that might be applicable to a wide range of business processes. Generally speaking, the schema could potentially be useful in any process involving the comparison, matching, weighting, or rating of a competency demanded against an actual available competency. While competencies have immediate relevancy to HR management processes, they also are relevant to certain business process outside the HR domain.
Examples of some of the principal HR management activities in which a standard for the exchange of competencies information could be valuable are described below.
Staffing the organization. Differing skill definitions and the use of widely varying skill taxonomies pose a barrier to efficient data interchange in many recruiting and staffing processes. Some employers have developed their own internal taxonomies of describing skills and competencies. Some of these taxonomies may be formal, whereas others may have developed informally over time. Other employers make use of third-party skills taxonomies. Job boards, staffing firms, and other recruiting and staffing venues also might have their own way of classifying positions by skill and/or industry and they also make use of internal as well as third-party skills taxonomies. Because of differing skill taxonomies, an employer might need to map its internal descriptors or taxonomies to those used by each of its recruiting and staffing vendors. Adding a new job board or vendor may require the creation of a new set of mappings.
A standard schema for competencies will make it easier to create mapping between different taxonomies.
Staffing data exchanges typically would take place between human resource management systems (HRMS) and recruiting systems and the systems of recruiting venues such as job boards and temporary staffing firms.
Developing the Workforce. A standard model for the exchange of competency information could have many uses in skills evaluation, gap analysis, and training. For example, a standard for competency information could enable gap analysis of a person’s current competency levels compared to the requirements of that person’s current position. Similarly, the standard could enable gap analysis between a person’s current competency level and that required by a target, or an aspired to, job or position. Gap analysis could be useful in determining available training to meet gap requirements and in forecasting training requirements across an organization or department.
The data exchanges might take place between HRMS, training development systems, and systems of vendors offering training programs.
Managing the Organizational Structure. This might involve reviewing the needs of an organization without considering personnel with existing positions. This process might involve a hierarchical breakdown of work and an assessment of competencies rated with relative weight at the optimal level by job. Once this is completed, one may create a model to support:
The data exchange might be between an organizational planning system and the human resource system.
Administering Compensation. A standard means for the exchange of competency information would have many uses in compensation administration:
Data exchanges would be between HRMS, performance management and appraisal systems, and a variety of compensation planning and administration systems.
A standard schema for the exchange of competency data has the potential to improve communication across many HR activities and to enhance business intelligence. A standard competencies schema has the potential to greatly simplify data transfer processes, thereby helping HR organizations save time and money. Many more cross-disciplinary transfers of business intelligence will be possible.
Job and position postings provide one of the clearest examples of data-exchange barriers and their associated costs. There is tremendous diversity in the way job boards classify the way jobs are advertised. Consequently, there is not an easy way to map between different classification systems. Because creating and maintaining mappings between an employer’s internal taxonomy and the ones used by job boards is difficult, many employers use third-party services to manage the mappings as well as handle the different formats required by different recruiting instruments. The use of a standard way of exchanging competency information within the HR-XML Consortium’s Staffing Exchange Protocol’s would make it much easier to create and maintain mappings and eliminate the extra expense of a posting middleman.
HR-XML competencies schema is designed to fulfill the following requirements:
The Competency schema is intended as a flexible, practical means to communicate both unstructured competency data (such as that that may be captured from a resume or profile) or structured competency data from a taxonomy.
Note that a separate schema, CompetencyTypes, is a container for competency-related data types. Initially, this schema will include elements and data types related to competency references (see Appendix B – Related Documents).
The Competencies schema is intended to be a fragment that can be incorporated within a wide-variety of process-specific schemas. Among the range of processes the competencies schema may help support are:
§ Assessments
§ 360º Feedback (Evaluation by Peers)
§ Other performance measurement instruments that measure competencies
§ Competency Modeling (an expert service)
§ Individual performance development planning and goal setting
§ Performance monitoring & reporting
§ Training curricula and individual courses that build competencies
§ Career development systems
§ Inventories of workforce competence (taxonomies for general and specialized uses)
§ Selection procedures that assess competencies
§ Succession planning systems
§ Pay-for-competencies compensation systems
§ Automated job descriptions
§ Core competencies for strategic planning
§ Recruiting
The following sections illustrate and explain the components of the HR-XML Consortium’s Competency Schema.
|
Component Name [Global types listed at the end of the table.] |
ContentModel* |
Definition |
|
/ |
CompetencyId
- [complexType] - S
(0/1) |
A specific, identifiable, definable, and measurable knowledge, skill, ability and/or other deployment-related characteristic (e.g. attitude, behavior, physical ability) which a human resource may possess and which is necessary for, or material to, the performance of an activity within a specific business context. |
|
/
Competency/ |
- xsd:string - |
The name for the related component. |
|
/ Competency/ |
- xsd:string - |
This optional attribute is available to provide additional information about the Id. |
|
/
Competency/ |
- xsd:boolean - |
A boolean used to indicate whether the CompetencyEvidence is mandatory for a particular position or given context. |
|
/
Competency/ |
id - xsd:string - required |
An identification code assigned to identify or classify the Competency. A taxonomy might include an identification code for each Competency or identification codes might be agreed upon by trading partners. |
|
/
Competency/ |
id - xsd:string - required |
A code that identifies the taxonomy. |
|
/
Competency/ |
EvidenceId
- [complexType] - S
(0/1) |
CompetencyEvidence is used to capture information to substantiate the existance, sufficiency, or level of a Competency. CompetencyEvidence might include test results, reports, performance appraisals, evaluations, certificates, licenses, or a record of direct observation, such as a report given by a former supervisor or other employment reference. |
|
/
Competency/ CompetencyEvidence/ |
id - xsd:string - required |
A code that identifies the CompetencyEvidence. |
|
/
Competency/ CompetencyEvidence/ |
xsd:extension base: xsd:double |
NumericValue is the required or measured level for the competency. The content of NumericValue is a rating value. The minValue, maxValue, interval, and description attributes of NumericValue provide information about the rating scale that is being used, so that the rating value can be interpreted. |
|
/
Competency/ CompetencyEvidence/ NumericValue/ |
- xsd:double - |
The minimum value of the rating scale. |
|
/
Competency/ CompetencyEvidence/ NumericValue/ |
- xsd:double - |
The maximum value of the rating scale. |
|
/
Competency/ CompetencyEvidence/ NumericValue/ |
- xsd:double - |
The increment or step for the relevant scale. |
|
/
Competency/ CompetencyEvidence/ NumericValue/ |
- xsd:string - |
This optional attribute is available to provide additional information about the Id. |
|
/ Competency/
CompetencyEvidence/ |
xsd:extension base: xsd:string |
StringValue is the required or measured level for the competency. The content of StringValue is a rating value. The minValue, maxValue, and name attributes of StringValue provide information about the rating scale that is being used, so that the rating value can be interpreted. |
|
/
Competency/ CompetencyEvidence/ StringValue/ |
- xsd:string - |
The minimum value of the rating scale. |
|
/
Competency/ CompetencyEvidence/ StringValue/ |
- xsd:string - |
The maximum value of the rating scale. |
|
/
Competency/ CompetencyEvidence/ StringValue/ |
- xsd:string - |
This optional attribute is available to provide additional information about the Id. |
|
/
Competency/ CompetencyEvidence/ |
- xsd:string - S (0/*) |
Contains additional descriptive information to substantiate or clarify a rating, measure, value, etc. |
|
/
Competency/ CompetencyEvidence/ |
- AnyDateTimeType - |
The date on which the CompetenceEvidence first establishes the existence of the Competency. |
|
/
Competency/ CompetencyEvidence/ |
- xsd:string - |
The name for the related component. |
|
/
Competency/ CompetencyEvidence/ |
- xsd:string - |
A description of the type of CompetencyEvidence. |
|
/ Competency/
CompetencyEvidence/ |
- AnyDateTimeType - |
The identification of any applicable expiration date, such as the date that a license or certification expires. |
|
/
Competency/ CompetencyEvidence/ |
- xsd:string - |
A code identifying the type of CompetencyEvidence. |
|
/
Competency/ CompetencyEvidence/ |
- xsd:boolean - |
A boolean used to indicate whether the CompetencyEvidence is mandatory for a particular position or given context. |
|
/ Competency/
CompetencyEvidence/ |
- AnyDateTimeType - |
A requirement or assertion for the date on which the Competency was last used. |
|
/
Competency/ |
NumericValue
- xsd:double - C
(1/1) |
CompetencyWeight allows the capture of information on the relative importance of the Competency or the sufficiency required or other type of dimension. An extensible “type” attribute is available so that custom weights or dimensions may be specified. Multiple CompetencyWeights are permitted since more than one type might apply to the competency. |
|
/
Competency/ CompetencyWeight/ |
xsd:extension base: xsd:double |
NumericValue is the required or desired level for the competency. The content of NumericValue is a rating value. The minValue, maxValue, interval, and description attributes of NumericValue provide information about the rating scale that is being used, so that the rating value can be interpreted. |
|
/
Competency/ CompetencyWeight/ NumericValue/ |
- xsd:double - |
The minimum value of the rating scale. |
|
/
Competency/ CompetencyWeight/ NumericValue/ |
- xsd:double - |
The maximum value of the rating scale. |
|
/
Competency/ CompetencyEvidence/ NumericValue/ |
- xsd:double - |
The increment or step for the relevant scale. |
|
/
Competency/ CompetencyWeight/ NumericValue/ |
- xsd:string - |
This optional attribute is available to provide additional information about the Id. |
|
/
Competency/ CompetencyWeight/ |
xsd:extension base: xsd:string |
StringValue is the required or measured level for the competency. The content of StringValue is a rating value. The minValue, maxValue, and name attributes of StringValue provide information about the rating scale that is being used, so that the rating value can be interpreted. |
|
/
Competency/ CompetencyWeight/ StringValue/ |
- xsd:string - |
The minimum value of the rating scale. |
|
/
Competency/ CompetencyWeight/ StringValue/ |
- xsd:string - |
The maximum value of the rating scale. |
|
/
Competency/ CompetencyWeight/ StringValue/ |
- xsd:string - |
This optional attribute is available to provide additional information about the Id. |
|
/
Competency/ CompetencyWeight/ |
- xsd:string - S (0/*) |
Contains additional descriptive information to substantiate or clarify a rating, measure, value, etc. |
|
/
Competency/ CompetencyWeight/ |
- ExtendedWeightType - |
Identifies the type of CompetencyWeight. Enumerated values are: levelOfInterest (A level of interest asserted or required for the competency) and skillLevel (A level of skill asserted or required for the competency). |
|
/ |
- [Union]: CompetencyWeightType,xStringPatternExtensionType |
Globally scoped data type. See element or attribute declaration for definition. |
|
/ |
xsd:restriction base: xsd:string [Enumerations]: levelOfInterest, skillLevel |
Globally scoped data type. See element or attribute declaration for definition. |
Competencies can have relationships to one another. One way that the Competencies schema allows these relationships to be expressed is through the recursive nesting of one competency inside another. Below are a few issues implementers should consider when using the schema’s recursive features:
§ Is recursion necessary to accurately capture or transfer information about the competency? Consider for instance, that each competency has a CompetencyId, which usually would be taken from an outside taxonomy. In some cases, it may be unnecessary to express a relationship between two competencies in the data transfer if the relationship is already clear within the outside taxonomy.
§ Does the extent of recursion impose undue complexity? The Competencies schema does not constrain the extent of recursion. However, there are likely to be limits to what is useful and practical. Nesting competencies beyond one or two levels generally is not advisable.
§ Is the relationship between the nested competencies clear?
In the process of developing the schema, the HR-XML Competencies workgroup discussed the desirability of being able to express relationships between
competencies in an explicit manner. Developing a taxonomy describing those
relationships was one idea that was explored. For instance, it might be
desirable to express that a child competency is related to a parent competency
by stating that the child “is a type of” the parent competency. Or
it might be desirable to express that a particular competency “has
a” particular component competency. The development this type of taxonomy
is outside the immediate scope of the initial version of the Competencies schema (See 1.3.2, Items Outside of Design Scope).
In the absence of an explicit way to express the relationship between a
parent and child competency, recursion should only be used where the
relationship between parent and child competencies is known by trading partners
or otherwise can be easily inferred. The Competency element has a description
attribute, which might be used to provide useful information about the
relationship between parent and child competencies.
|
Date |
Description |
|
2001-07-31 |
First Draft |
|
2001-08-21 |
Added issues list, updated diagram. |
|
2001-08-29 |
Added Reference Examples |
|
2001-08-30 |
Add SupportingInformation element and description. Recommendation of schema. |
|
2001-09-04 |
Changed MeasuredValue to a choice of NumericValue and StringValue. Made numerous typographical changes. Clarified that the description of measurement systems/scales is outside of the initial project scope. Changed “Psychometric (Personality) testing” to Psychometric testing. |
|
2001-09-17 |
Made changes per CPO review: Weight to CompetencyWeight; added implementation guidance on recursiveness; added bullet on measurement scales (outside of scope); changed xsd:data to AnyDateTime Type; changed required attribute to Boolean from yes/no enumeration. |
|
2001-Oct-16 |
Approved Recommendation by HR-XML Consortium |
|
2002-Dec-16 |
Draft for Version 1.1 enhancements |
|
2003-Jan-9 |
Approved by Recruiting and Staffing for submission to CPO/TSC. |
|
2003-Feb-26 |
Approved recommendation by HR-XML Consortium. The default and targetNamespaces of all HR-XML schemas have been standardized to "http://ns.hr-xml.org". This recommendation is available as part of the HR-XML 2_0 architecture. |
|
2005-June-29 |
Added description of new interval attribute on numeric value. |
|
2005-Dec-15 |
Minor edits related to feedback from CPO. Memorialized in workgroup mailing list archives. |
|
2006-Feb-28 |
Approved by Consortium |
|
2007-Apr-15 |
Approved by Consortium |
|
Reference |
Link |
|
IMS Reusable Competency Definitions Information Model
|
http://www.imsglobal.org/
|
|
Competency Schema |
|
|
CompetencyTypes |
|
|
DateTimeDataTypes |
http://ns.hr-xml.org/2_5/HR-XML-2_5/CPO/DateTimeDataTypes.html http://ns.hr-xml.org/2_5/HR-XML-2_5/CPO/DateTimeDataTypes.xsd |
This example shows an employee who has Java as a competency. Acme Company, using their standard Java test, tested this employee. The candidate’s test score was 89 on that test. In addition, it’s recorded that the employee has 4 years of experience using Java and on a scale from 1-100, has a score of 90 for their level of interest.
<Competency description="Java is an object oriented computer language" name="Java">
<CompetencyId description="Competency id is based on Acme internal taxonomy" id="574" idOwner="Acme Company"/>
<TaxonomyId description="My ids are based on Acme Company Taxonomy" idOwner="Acme Company" id="1"/>
<CompetencyEvidence dateOfIncident="2001-08-23" name="Test Score" typeDescription="Test Score from internal test" typeId="54">
<EvidenceId description="Java Test from internally administered test" id="547" idOwner="Acme Company"/>
<NumericValue description="100 point scale" maxValue="100" minValue="0">89</NumericValue>
</CompetencyEvidence>
<CompetencyEvidence dateOfIncident="2001-08-23" name="Years of Experience" typeDescription="Years of Experience" typeId="7">
<EvidenceId description="Years of Experience in Competency" id="7" idOwner="Acme Company"/>
<NumericValue description="Range in years for experience">4</NumericValue>
</CompetencyEvidence>
<CompetencyWeight type="levelOfInterest">
<NumericValue description="Acme Company Scale 100 point" maxValue="100" minValue="0">90</NumericValue>
</CompetencyWeight>
</Competency>
This example shows a candidate’s competency to drive a car. The evidence used in this example is a valid drivers license that was obtained on 12/23/1986. The measured value in this case is simply 0 or 1 (1 meaning that the candidate has it, 0 meaning they don’t).
<Competency description = "Licensed to drive" name = "Drivers License">
<CompetencyId description = "Competency id is based on Acme internal taxonomy" id = "233" idOwner = "Acme Company"/>
<TaxonomyId description = "My ids are based on Acme Company Taxonomy" idOwner = "Acme Company" id = "1"/>
<CompetencyEvidence dateOfIncident = "1986-12-23" name = "License" typeDescription = "Drivers License" typeId = "231">
<EvidenceId description = "Valid Minnesota Drivers License" id = "W9D X8S8" idOwner = "Minnesota DMV"/>
<NumericValue description = "Scale of 0 or 1" maxValue = "1" minValue = "0">1</NumericValue>
</CompetencyEvidence>
</Competency>
This example shows a candidate’s competency fulfilling a requirement for Bachelors Degree. The evidence used in this example is the Bachelors Degree itself, which was obtained on 05/21/1992. The measured value in this case is simply 0 or 1 (1 meaning that the candidate has it, 0 meaning they don’t). For additional evidence, the Grade Point average for the degree is presented as additional evidence. In this case, the grade point average is 3.76.
<Competency description="College Degree" name="College Degree">
<CompetencyId description="Competency id is based on Acme internal taxonomy" id="233" idOwner="Acme Company"/>
<TaxonomyId description="My ids are based on Acme Company Taxonomy" idOwner="Acme Company" id="1"/>
<CompetencyEvidence dateOfIncident="1992-05-21" name="Degree" typeDescription="College Degree" typeId="231">
<EvidenceId description="Bachelor's degree from accredited school" id="100" idOwner="University of Wisconsin"/>
<NumericValue description="Scale of 0 or 1" maxValue="1" minValue="0">1</NumericValue>
</CompetencyEvidence>
<CompetencyEvidence dateOfIncident="1992-05-21" name="GPA" typeDescription="Grade Point Average for Degree" typeId="101">
<EvidenceId description="GPA" id="101" idOwner="University of Wisconsin"/>
<NumericValue description="Scale of 0 or 4" maxValue="4" minValue="0">3.76</NumericValue>
</CompetencyEvidence>
</Competency>
Communication skills can be made up of two skills: written and oral communication skills. Written and oral communication skills are the measurable and observable skills to which an employee/applicant will be measured. In order to assess whether a person has Communication Skills, it is necessary to evaluate the person’s written and oral communication skills (the measurable and observable skills). This example weights oral communication skills higher (65 percent) than written communication skills (35 percent).
<Competency name="Communication Skills">
<Competency name="Written Communication Skills">
<CompetencyEvidence name="WRITTENTEST1-A" dateOfIncident="1995-01-01" lastUsed="2000-01-01">
<NumericValue minValue="3" maxValue="5" description="SEP-equivalent Skill-Level Range">5</NumericValue>
</CompetencyEvidence>
<CompetencyWeight>
<NumericValue minValue="0" maxValue="100">35</NumericValue>
</CompetencyWeight>
</Competency>
<Competency name="Oral Communication Skills">
<CompetencyEvidence name="ManagerObservation" dateOfIncident="1996-01-01" lastUsed="2000-01-01">
<NumericValue minValue="1" maxValue="5" description="Company XYZ Skill Range">5</NumericValue>
</CompetencyEvidence>
<CompetencyWeight>
<NumericValue minValue="0" maxValue="100">65</NumericValue>
</CompetencyWeight>
</Competency>
</Competency>
One type of skill that is important for many jobs is that of language. It is not sufficient to say that someone is “fluent” in a language. It is important, especially when looking at what an employee is required to do for a particular job, to look at how the language skill is being used. It may be very important for the individual to know how to read a particular language but there may not be any need to be able to write or to speak it. In other jobs, it may be important to be able to speak a particular language but there may not be any need to be able to write or read in that language.
<Competency name="Speaking Spanish">
<CompetencyEvidence name="Spanish Language Oral Proficiency Interview" dateOfIncident="1995-01-01" lastUsed="2000-01-01">
<NumericValue minValue="1" maxValue="5" description="oral proficiency interview rating">5</NumericValue>
</CompetencyEvidence>
</Competency>
There are certain skills that need to be assessed, evaluated and evidenced through direct observation. One example of this would be customer service. A manager may observe an employee dealing with customers and notice how the employee treats the customers. It may be difficult to test for customer service and it may be difficult to assess customer service based only on customer feedback.
<?xml version="1.0" encoding="UTF-8"?>
<Competency name="Customer Service" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://ns.hr-xml.org/2004-08-02" xsi:schemaLocation="http://ns.hr-xml.org/2004-08-02 Competencies.xsd">
<CompetencyEvidence name="ManagerObservation" dateOfIncident="1995-01-01" lastUsed="2000-01-01">
<NumericValue minValue="4" maxValue="5" description="Company ABC Skill Level Range">5</NumericValue>
</CompetencyEvidence>
</Competency>
The Occupational Information Network (O*Net) is a database of worker attributes and job characteristics. It defines a common language for defining and describing occupations. This taxonomy contains information about knowledge, skills, abilities, interests, general work activities and work context. The United States Department of Labor (DOL) funds the O*NET program.
The O*Net database is representative of the type of data that can be captured and exchanged using the HR-XML Consortium Competency schema. The governments of other countries as well as a variety of private organizations publish similar skills taxonomies. The following information is intended to be illustrative of how an implementer might exchange data from a skills taxonomy. O*Net is not the only taxonomy one might use in conjunction with the HR-XML Competencies specification. There are business cases for exchanging skills data using a variety of taxonomies. In some cases, an implementer might want to refer to both a third-party taxonomy (such as O*Net) as well as a taxonomy that is used internally. The HR-XML Consortium’s Competencies specification could make managing multiple taxonomies easier.
The O*Net data presented below is provided for illustrative purposes only. It is presented out of context of the O*Net database. For further information on O*Net, see http://online.onetcenter.org
The following are selections from the O*Net 3.1 Database and examples of how they might be captured using the HR-XML Competencies specification.
|
Skills |
Description |
Element ID |
Importance |
Level |
Scale |
|
Reading Comprehension |
Understanding written sentences and paragraphs in work related documents |
2.A.1.a |
85 |
57 |
1-100 |
<Competency name="Reading Comprehension" description="Understanding written sentences and paragraphs in work related documents">
<CompetencyId id="2.A.1.a"/>
<TaxonomyId id="O*NET" idOwner="National O*Net Consortium" description="Occupational Information Network"/>
<CompetencyWeight type="x:Importance">
<NumericValue maxValue="100" minValue="1">85</NumericValue>
</CompetencyWeight>
<CompetencyWeight type="x:Level">
<NumericValue maxValue="100" minValue="1">57</NumericValue>
</CompetencyWeight>
</Competency>
|
Abilities |
Description |
Element ID |
Importance |
Level |
Scale |
|
Oral Comprehension |
The ability to listen to and understand information and ideas presented through spoken words and sentences |
1.A.1.a.1 |
65 |
57 |
1-100 |
<Competency name="Oral Comprehension" description="The ability to listen to and understand information and ideas presented through spoken words and sentences">
<CompetencyId id="1.A.1.a.1"/>
<TaxonomyId id="O*NET" idOwner="National O*Net Consortium" description="Occupational Information Network"/>
<CompetencyWeight type="x:Importance">
<NumericValue maxValue="100" minValue="1">65</NumericValue>
</CompetencyWeight>
<CompetencyWeight type="x:Level">
<NumericValue maxValue="100" minValue="1">57</NumericValue>
</CompetencyWeight>
</Competency>
|
Knowledge |
Description |
Element ID |
Importance |
Level |
Scale |
|
Clerical |
Knowledge of administrative and clerical procedures and systems such as word processing systems, filing and records management systems, stenography and transcription, forms design principles, and other office procedures and terminology |
2.C.1.b |
92 |
74 |
1-100 |
<Competency name="Clerical" description="Knowledge of administrative and clerical procedures and systems such as word processing systems, filing and records management systems, stenography and transcription, forms design principles, and other office procedures and terminology">
<CompetencyId id="2.C.1.b"/>
<TaxonomyId id="O*NET" idOwner="National O*Net Consortium" description="Occupational Information Network"/>
<CompetencyWeight type="x:Importance">
<NumericValue maxValue="100" minValue="1">92</NumericValue>
</CompetencyWeight>
<CompetencyWeight type="x:Level">
<NumericValue maxValue="100" minValue="1">74</NumericValue>
</CompetencyWeight>
</Competency>
|
Work Activities |
Description |
Element ID |
Importance |
Level |
Freq. |
Scale |
|
Performing Administrative Activities |
Approving requests, handling paperwork, and performing day-to-day administrative tasks. |
4.A.4.c.1 |
100 |
52 |
100 |
1-100 |
<Competency name="Performing Administrative Activities" description="Approving requests, handling paperwork, and performing day-to-day administrative tasks.">
<CompetencyId id="4.A.4.c.1"/>
<TaxonomyId id="O*NET" idOwner="National O*Net Consortium" description="Occupational Information Network"/>
<CompetencyWeight type="x:Importance">
<NumericValue maxValue="100" minValue="1">100</NumericValue>
</CompetencyWeight>
<CompetencyWeight type="x:Level">
<NumericValue maxValue="100" minValue="1">52</NumericValue>
</CompetencyWeight>
<CompetencyWeight type="x:Frequency">
<NumericValue maxValue="100" minValue="1">100</NumericValue>
</CompetencyWeight>
</Competency>
The example below shows how an implementer might qualify or elaborate on a standard O*Net definition with privately defined criteria.
<Competency name="Clerical" description="Knowledge of administrative and clerical procedures and systems such as word processing systems, filing and records management systems, stenography and transcription, forms design principles, and other office procedures and terminology">
<CompetencyId id="2.C.1.b"/>
<TaxonomyId id="O*NET" idOwner="National O*Net Consortium" description="Occupational Information Network"/>
<CompetencyWeight type="x:Importance">
<NumericValue maxValue="100" minValue="1">92</NumericValue>
</CompetencyWeight>
<CompetencyWeight type="x:Level">
<NumericValue maxValue="100" minValue="1">74</NumericValue>
</CompetencyWeight>
<Competency name="MS Office Proficiency" description="Proficency with Microsoft Word, Excel, Access, and other components of MS Office" required="true">
<CompetencyEvidence required="true" name="Acme Corp MS Office Proficency Test" typeDescription="A standard test of MS Office proficency for the administrative employees of Acme Corp">
<NumericValue minValue="0" maxValue="100">85</NumericValue>
</CompetencyEvidence>
</Competency>
</Competency>
[1] Competency-Centric Human Resource Management, Prepared by Naomi Lee Bloom, Bloom & Wallace, HR-XML Consortium Quarterly Meeting, Pleasanton, California, October 16-17, 2000


| Figure 1 |
Stratigraphic variation in organic molecules derived from co ... |
| Figure 2 |
Climate changes caused by the black carbon (BC) injection. ( ... |
| Figure 3 |
Meridional distributions of pre-industrial climate condition ... |
| Figure 4 |
Global distributions of precipitation before and after the b ... |
| Figure 5 |
Seawater temperature changes caused by the black carbon (BC) ... |
| Figure 6 |
Meridional distributions of pre-industrial seawater temperat ... |
| Figure 7 |
Changes in sea surface temperature (SST) caused by the black ... |


filmcritic.com presents a review from staff member Aileo Weinmann. You can find the review with full credits at http://www.filmcritic.com/misc/emporium.nsf/2a460f93626cd4678625624c007f2b46/59d470566965c60188256875000b31e5?OpenDocument
The Big Tease
A film review by Aileo Weinmann – Copyright Ó 2000 filmcritic.com
Director: Kevin Allen Producer: Kevin Allen, Philip Rose, Sacha Gervasi, Craig Ferguson Screenwriter: Sacha Gervasi, Craig Ferguson Stars: Craig Ferguson, Frances Fisher, Mary McCormack, David Rasche, Chris Langham MPAA Rating: R Year of Release: 1999
Cut, Curl, Crimp, Color. THE BIG TEASE is a mockumentary tracing flamboyant gay hairdresser Crawford Mackenzie's (Craig Ferguson – THE DREW CAREY SHOW) unlikely journey from Scotland to Los Angeles in his quest to win the World International Hairdressing Federation's (WIHF) Platinum Scissors Competition. The adventurous bumbling begins when MacKenzie mistakes a form letter – asking him to be part of the audience – for an invitation to compete against three of the world's top stylists, including his idol and the reigning Platinum Scissors holder Stig Ludwiggssen (David Rasche).
Accompanied by filmmaker Martin (Chris Langham – BBC's KISS ME KATE), Mackenzie travels to LA, where he plans to finally claim the artistic recognition and fame that his small Scotland hometown can't offer. (Except for that time he got to dry Sean Connery's toupee after it fell into some water on a golf course). Upon arriving in California, he kicks up his kilt and happily takes advantage of what he assumes are complimentary hotel amenities, only to wake up to the reality of a maxed out credit card. His passport now held collateral on his outstanding charges, he proceeds to WIHF headquarters, expecting to clear up the confusion and get reimbursed. Unfortunately, WIHF President Monique (Mary McCormack) is not about to pick up the tab for Mackenzie's misunderstanding, nor does she plan to allow him to enter the competition. Undaunted, the remainder of the comedy unfolds in his search of any and every way to gain entry in the prestigious contest. Antics include befriending celebrity promoter Candy Harper (Frances Fisher), calling on Sean Connery (to return a favor), and visiting a testosterone-oozing Senator whose company sponsors the WIHF event.
Ferguson plays the eccentric hairdresser with finesse – he's silly and endearing in his portrayal of destiny to attain the coveted Platinum Scissors. Chris Langham does a fine job with his feeble character, providing a constant if not invisible sidekick for Mackenzie. Frances Fisher is great in her role as Mackenzie's compassionate and determined advocate, demonstrating her versatility, in contrast with more serious roles in films like TITANIC, UNFORGIVEN, and TRUE CRIME. Cameo performances by Drew Carey, David Hasselhoff, Cathy Lee Crosby, and John Paul DeJoria (a.k.a. John Paul Mitchell, stylist extraordinaire) are sprinkled to provide that true Hollywood feel.
Overall, THE BIG TEASE holds no real surprises, but the culminating scene is outrageously over-the-top and doesn't disappoint. Although the mockumentary format was strained and became somewhat annoying at times, it's not enough to kill the general cuteness and entertainment of the production. Zany characters, bigtime costumes and an originally absurd premise (a world championship of hairstyling ?!?) offer as many smiles as I remember from spinning around in the chair at the barber shop.
*** 3 stars
-- Christopher Null -<EMAIL_ADDRESS>- http://www.filmcritic.com
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


class Capybara::RSpecMatchers::BecomeClosed
Public Class Methods
new(options)
click to toggle source
# File lib/capybara/rspec/matchers.rb, line 179 def initialize(options) @options = options end
Public Instance Methods
failure_message()
click to toggle source
# File lib/capybara/rspec/matchers.rb, line 194 def failure_message "expected<EMAIL_ADDRESS>to become closed after #{@wait_time} seconds" end
Also aliased as: failure_message_for_should
failure_message_when_negated()
click to toggle source
# File lib/capybara/rspec/matchers.rb, line 198 def failure_message_when_negated "expected<EMAIL_ADDRESS>not to become closed after #{@wait_time} seconds" end
Also aliased as: failure_message_for_should_not
matches?(window)
click to toggle source
# File lib/capybara/rspec/matchers.rb, line 183 def matches?(window) @window = window @wait_time = Capybara::Queries::BaseQuery.wait(@options, window.session.config.default_max_wait_time) start_time = Capybara::Helpers.monotonic_time while window.exists? return false if (Capybara::Helpers.monotonic_time - start_time) > @wait_time sleep 0.05 end true end


HTML5
HTML5[a] is a markup language used for structuring and presenting content on the World Wide Web. It is the fifth and current major version of the HTML standard.
It was published in October 2014 by the World Wide Web Consortium (W3C)[2][4] to improve the language with support for the latest multimedia, while keeping it both easily readable by humans and consistently understood by computers and devices such as web browsers, parsers, etc. HTML5 is intended to subsume not only HTML 4, but also XHTML 1 and DOM Level 2 HTML.[5]
HTML5 includes detailed processing models to encourage more interoperable implementations; it extends, improves and rationalizes the markup available for documents, and introduces markup and application programming interfaces (APIs) for complex web applications.[6] For the same reasons, HTML5 is also a candidate for cross-platform mobile applications, because it includes features designed with low-powered devices in mind.
The APIs and Document Object Model (DOM) are now fundamental parts of the HTML5 specification[6] and HTML5 also better defines the processing for any invalid documents.