Reference
verbose
int
default: 2
Verbosity level
0
= off1
= show progress2
= show statistics
output
str
default: ./
Directory or filename of the output.
- If a directory, it must end with
/
. In that case, the filename will be the name of the yaml config file. - If a filename, it must end with
.png
. Note that a number is attached to the filename or is automatically increased, if the file already exists.
snapshot_interval
int, float
default: 20.0
Interval after which a snapshot of the currently trained image is saved.
A float number specifies the interval in seconds. An integer number specifies the interval in number-of-epochs.
A zero (either int of float) disables storage of snapshots.
epochs
int
default: 300
The number of training steps before stopping the training, not including batch sizes.
For example, if the number of epochs is 100
and a target has a batch_size of 10
,
then 1000
training steps will be performed.
start_epoch
int
default: 0
The number of epochs to skip in the beginning.
This is used by the GUI application to continue training after config changes.
resolution
list of length 2 of int
default: [224, 224]
expression variables: time
Resolution of the image to create. A single number for square images or two numbers for width and height.
It supports expression variables so you can actually change the resolution during training, e.g:
resolution: - 224 if t < .2 else 448
would change the resolution from 224x224 to 448x448 at 20% of training time.
model
str
default: ViT-B/32
The pre-trained CLIP model to use. Options are RN50
, RN101
, RN50x4
, ViT-B/32
The models are downloaded from openaipublic.azureedge.net
and stored in the user's ~/.cache/
directory
device
str
default: auto
The device to run the training on. Can be cpu
, cuda
, cuda:1
etc.
learnrate
float
default: 1.0
expression variables: resolution, time
The learning rate of the optimizer.
Different optimizers have different learning rates that work well.
However, this value is scaled by hand so that 1.0
translates to
about the same learning rate for each optimizer.
The learnrate value is available to other expressions as lr
or learnrate
.
learnrate_scale
float
default: 1.0
expression variables: resolution, time
A scaling parameter for the actual learning rate.
It's for convenience in the case when learnrate_scale is an expression like 1. - t
.
The actual learnrate can be overridden with fixed values like 2
or 3
in
different experiments.
The learnrate_scale value is available to other expressions as lrs
or learnrate_scale
.
optimizer
str
default: adam
The torch optimizer to perform the gradient descent.
init
Defines the way, the pixels are initialized. Default is random pixels.
init.resolution
list of length 2 of int
no default
This can alter the resolution of the noise or loaded image before it is converted to the resolution of the training image.
init.mean
list of length 3 of float
default: [0.5, 0.5, 0.5]
The mean (brightness) of the initial pixel noise.
Can be a single number for gray or three numbers for RGB.
init.std
list of length 3 of float
default: [0.1, 0.1, 0.1]
The standard deviation (randomness) of the initial pixel noise.
A single number will be copied to the RGB values.
init.image
str
no default
A filename of an image to use as starting point.
The image will be scaled to the desired resolution if necessary.
init.image_tensor
list
no default
A 3-dimensional matrix of pixel values in the range [0, 1]
The layout is the same as used in
torchvision,
namely [C, H, W]
, where C
is number of colors (3),
H
is height and W
is width.
This is used by the GUI application to continue training after config changes.
targets
This is a list of targets that define the desired image.
Most important are the features where texts or images are defined which get converted into CLIP features and then drive the image creation process.
It's possible to add additional constraints which alter image creation without using CLIP, e.g. the image mean, saturation or gaussian blur.
targets.active
bool
default: True
A boolean to turn off the target during development.
This is just a convenience parameter. To turn of a target
during testing without deleting all the parameters, simply
put active: false
inside.
targets.name
str
default: target
The name of the target.
Currently this is just displayed in the statistics dump and has no functionality.
targets.start
int, float
default: 0.0
Start frame of the target. The whole target is inactive before this time.
- an
int
number defines the time as epoch frame - a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.
targets.end
int, float
default: 1.0
End frame of the target. The whole target is inactive after this time.
- an
int
number defines the time as epoch frame - a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.
targets.weight
float
default: 1.0
expression variables: learnrate, resolution, target constraint, time
Weight factor that is multiplied with all the weights of features and constraints.
targets.batch_size
int
default: 1
The number of image frames to process during one epoch.
In machine learning the batch size is one of the important and magic hyper-parameters. They control how many different training samples are included into one weight update.
With CLIPig we are not training a neural network or anything complicated, we just adjust pixel colors, so different batch sizes probably do not make as much difference to the outcome.
However, increasing the batch size certainly reduces the overall computation time. E.g. you can run an experiment for 1000 epochs with batch size 1, or for 100 epochs with a batch size of 10. The latter is much faster. Basically, you can increase the batch size until memory is exhausted.
targets.select
str
default: all
Selects the way how multiple features are handled.
all
: All feature losses (multiplied with their individual weights) are added together.best
: The similarity between the features of the current image pixels and each desired feature is calculated and the feature with the highest similarity is chosen to adjust the pixels in it's direction.worst
: Similar to thebest
selection mode, the current similarity is calculated and then the worst matching feature is selected. Whilebest
mode will generally increase the influence of one or a few features, theworst
mode will try to increase the influence of all features equally.mix
: All individual features are averaged together (respecting their individual weights) and the resulting feature is compared with the features of the current image. This actually works quite well!
targets.feature_scale
str
default: equal
Adjusts the initial scaling of the similarity between training image and this feature.
equal
: All factors are 1.fair
: Factors are set such that the initial frame of the training image has the same similarity with each feature.
targets.features
A list of features to drive the image creation.
The CLIP network is used to convert texts or images into a 512-dimensional vector of latent variables.
In the image creation process each target takes a section of the current image, shows it to CLIP and compares the resulting feature vector with the vector of each defined feature.
Through backpropagation each pixel is then slightly adjusted in a way that would make the CLIP feature more similar to the defined features.
targets.features.text
str
no default
A word, sentence or paragraph that describes the desired image contents.
CLIP does understand english language fairly good, also some phrases in other languages.
targets.features.image
str
no default
Path or URL to an image file (supported formats).
Alternatively to text an image can be converted into the target feature.
Currently the image is resized to 224x224, ignoring the aspect-ratio to fit into the CLIP input window.
If the path starts with http://
or https://
it's treated as an URL and the image
is downloaded and cached in ~/.cache/img/<md5-hash-of-url>
.
targets.features.start
int, float
default: 0.0
Start frame of the specific feature
- an
int
number defines the time as epoch frame - a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.
targets.features.end
int, float
default: 1.0
End frame of the specific feature
- an
int
number defines the time as epoch frame - a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.
targets.features.weight
float
default: 1.0
expression variables: learnrate, resolution, target feature, time
A weight parameter to control the influence of a specific feature of a target.
Note that you can use negative weights as well which translates roughly to: Generate an image that is the least likely to that feature.
targets.features.scale
float
default: 1.0
expression variables: learnrate, resolution, target feature, time
A scaling parameter that is multiplied with the similarity value to yield the actual similarity used, e.g., for best_match select.
targets.features.loss
str
default: cosine
The loss function used to calculate the difference (or error) between current and desired feature.
cosine
: The loss function is1 - cosine_similarity(current, target)
. The CLIP network was trained using cosine similarity so that is the default setting.l1
ormae
: Mean absolute error is the mean of the absolute difference of each vector variable.l2
ormse
: Mean squared error is the mean of the squared difference of each vector variable. Compared to mean absolute error, it produces a smaller loss for small differences (below 1.0) and a larger loss for large differences.
targets.transforms
Transforms shape the area of the trained image before showing it to CLIP for evaluation.
targets.transforms.add
list of length 3 of float
no default
expression variables: learnrate, resolution, time
Adds a fixed value to all pixels.
Three numbers specify red, green and blue while a single number specifies a gray-scale color.
targets.transforms.blur
A gaussian blur is applied to the pixels.
See torchvision gaussian_blur.
targets.transforms.blur.kernel_size
list of length 2 of int
default: [3, 3]
expression variables: learnrate, resolution, time
The size of the pixel window. Must be an odd, positive integer.
Two numbers define width and height separately.
targets.transforms.blur.sigma
list of length 2 of float
no default
expression variables: learnrate, resolution, time
Gaussian kernel standard deviation. The larger, the more blurry.
If not specified it will default to 0.3 * ((kernel_size - 1) * 0.5 - 1) + 0.8
.
Two numbers define sigma for x and y separately.
targets.transforms.border
Draws a border on the edge of the image. The resolution is not changed.
targets.transforms.border.size
list of length 2 of int
default: [1, 1]
expression variables: learnrate, resolution, time
One integer two specify width and height at the same time, or two integers to specify them separately.
targets.transforms.border.color
list of length 3 of float
default: [0.0, 0.0, 0.0]
expression variables: learnrate, resolution, time
The color of the border as float numbers in the range [0, 1]
.
Three numbers for red, green and blue or a single number to specify a gray-scale.
targets.transforms.bwnoise
float
no default
expression variables: learnrate, resolution, time
Adds gray-scale noise to the image.
The noise has a scalable normal distribution around zero.
Specifies the standard deviation of the noise distribution.
targets.transforms.center_crop
list of length 2 of int
no default
expression variables: learnrate, resolution, time
Crops an image of the given resolution from the center.
One integer for square images, two numbers to specify width and height.
targets.transforms.clamp
list of length 2 of float
no default
expression variables: learnrate, resolution, time
Clamps the pixels into a fixed range.
First number is the minimum allowed value for all color channels, second is the maximum allowed value.
An image displayed on screen or converted to a file does only include
values in the range of [0, 1]
.
targets.transforms.crop
list of length 4 of float
no default
expression variables: learnrate, resolution, time
Crops a specified section from the image.
4 numbers: x and y of top-left corner followed by width and height.
A number between 0 and 1 is considered a fraction of the full resolution. A number greater or equal to 1 is considered a pixel coordinate
targets.transforms.edge
This removes everything except edges and generally has a bad effect on image quality. It might be useful, however.
A gaussian blur is used to detect the edges:
edge = amount * abs(image - blur(image))
targets.transforms.edge.kernel_size
list of length 2 of int
default: [3, 3]
expression variables: learnrate, resolution, time
The size of the pixel window used for gaussian blur. Must be an odd, positive integer.
Two numbers define width and height separately.
targets.transforms.edge.sigma
list of length 2 of float
no default
expression variables: learnrate, resolution, time
Gaussian kernel standard deviation. The larger, the more blurry.
If not specified it will default to 0.3 * ((kernel_size - 1) * 0.5 - 1) + 0.8
.
Two numbers define sigma for x and y separately.
targets.transforms.edge.amount
list of length 3 of float
default: [1.0, 1.0, 1.0]
expression variables: learnrate, resolution, time
A multiplier for the edge value. Three numbers to specify red, green and blue separately.
targets.transforms.fnoise
list of length 3 of float
no default
expression variables: learnrate, resolution, time
Adds noise to the image's fourier space.
It's just a bit different than the normal noise.
The noise has a scalable normal distribution around zero.
Specifies the standard deviation of the noise distribution.
The actual value is multiplied by 15.0
to give a visually
similar distribution as the normal noise.
One value or three values to specify red, green and blue separately.
targets.transforms.mean
list of length 3 of float
no default
expression variables: learnrate, resolution, time
Adjust the mean color value.
Three numbers specify red, green and blue while a single number specifies a gray-scale color.
targets.transforms.mul
list of length 3 of float
no default
expression variables: learnrate, resolution, time
Multiplies all pixels by a fixed value.
Three numbers specify red, green and blue while a single number specifies a gray-scale color.
targets.transforms.noise
list of length 3 of float
no default
expression variables: learnrate, resolution, time
Adds noise to the image.
The noise has a scalable normal distribution around zero.
Specifies the standard deviation of the noise distribution.
One value or three values to specify red, green and blue separately.
targets.transforms.pad
Pads the image with additional pixels at the borders.
targets.transforms.pad.size
list of length 2 of int
no default
expression variables: learnrate, resolution, time
The number of columns/rows to add.
One integer to specify x and y at the same time, or two integers to specify them separately.
E.g. 1, 2
would add 1 column left and one column right of
the image and two rows on top and bottom respectively.
targets.transforms.pad.color
list of length 3 of float
default: [0.0, 0.0, 0.0]
expression variables: learnrate, resolution, time
The color of the pixels that are padded around the image.
targets.transforms.pad.mode
str
default: fill
expression variables: learnrate, resolution, time
The way the padded area is filled.
fill
: fills everything with thecolor
valueedge
: repeats the edge pixelswrap
: repeats the image from the opposite edge
targets.transforms.random_crop
list of length 2 of int
no default
expression variables: learnrate, resolution, time
Crops a section of the specified resolution from a random position in the image.
One integer for square images, two numbers to specify width and height.
targets.transforms.random_rotate
Randomly rotates the image.
Degree and center of rotation are chosen randomly between in the range of the specified values.
The resolution is not changed and areas outside of the image are filled with black (zero).
targets.transforms.random_rotate.degree
list of length 2 of float
no default
expression variables: learnrate, resolution, time
The minimum and maximum counter-clockwise angle of ration in degrees.
targets.transforms.random_rotate.center
list of length 2 of float
default: [0.5, 0.5]
expression variables: learnrate, resolution, time
The minimum and maximum center of rotation (for x and y) in the range [0, 1]
.
targets.transforms.random_scale
list of length 2 of float
no default
expression variables: learnrate, resolution, time
Randomly scales an image in the range specified.
The resolution does not change, only contents are scaled. Areas outside of the image are filled with black (zero).
Minimum and maximum scale, where 0.5
means half and 2.0
means double.
targets.transforms.random_shift
list of length 2 or 4 of float
no default
expression variables: learnrate, resolution, time
This randomly translates the pixels of the image.
Pixels that are moved outside get attached on the other side.
Specifies the random range of translation.
A number larger 1 or smaller -1 translates by the actual pixels.
A number between -1 and 1 translates by the fraction of the image resolution.
E.g., shift: 0 1
would randomly translate the image to every possible position
given it's resolution.
Two numbers specify minimum and maximum shift both axis, four numbers specify minimum and maximum shift for axis x and y respectively.
targets.transforms.random_translate
list of length 2 of float
no default
expression variables: learnrate, resolution, time
Randomly translates an image in the specified range.
The resolution does not change. Areas outside of the image are filled with black (zero).
Maximum absolute fraction for horizontal and vertical translations.
For example: random_translate: a, b
, then horizontal shift is randomly sampled in
the range -img_width * a < dx < img_width * a
and vertical shift is randomly sampled in the range
-img_height * b < dy < img_height * b
.
targets.transforms.repeat
list of length 2 of int
no default
expression variables: learnrate, resolution, time
Repeats the image a number of times in the right and bottom direction.
One integer to specify x and y at the same time, or two integers to specify them separately.
targets.transforms.resize
list of length 2 of int
no default
expression variables: learnrate, resolution, time
The resolution of the image is changed.
One integer for square images, two numbers to specify width and height.
targets.transforms.rnoise
Adds noise with a different resolution to the image.
The noise has a scalable normal distribution around zero.
targets.transforms.rnoise.std
list of length 3 of float
no default
expression variables: learnrate, resolution, time
Specifies the standard deviation of the noise distribution.
One value or three values to specify red, green and blue separately.
targets.transforms.rnoise.resolution
list of length 2 of int
no default
expression variables: learnrate, resolution, time
The resolution of the noise image. It will be resized to the processed image.
targets.transforms.rotate
Rotates the image.
The resolution is not changed and areas outside of the image are filled with black (zero).
targets.transforms.rotate.degree
float
no default
expression variables: learnrate, resolution, time
The counter-clockwise angle of ration in degrees ([0, 360]
).
targets.transforms.rotate.center
list of length 2 of float
default: [0.5, 0.5]
expression variables: learnrate, resolution, time
The center of rotation in the range [0, 1]
.
Two numbers to specify x and y separately.
targets.transforms.shift
list of length 2 of float
no default
expression variables: learnrate, resolution, time
This translates the image while wrapping the edges around.
Pixels that are moved outside get attached on the other side.
A number larger 1 or smaller -1 translates by the actual pixels.
A number between -1 and 1 translates by the fraction of the image resolution.
E.g., shift: .5
would move the center of the image to the previous bottom-right
corner.
A single number specifies translation on both x and y axes while two numbers specify them separately.
postproc
A list of post-processing effects that are applied every epoch and change the image pixels directly without interfering with the backpropagation stage.
All transforms that do not change the resolution are available as post processing effects.
postproc.active
bool
default: True
A boolean to turn of the post-processing stage during development.
This is just a convenience parameter. To turn of a stage
during testing without deleting all the parameters, simply
put active: false
inside.
postproc.start
int, float
default: 0.0
Start frame for the post-processing stage. The stage is inactive before this time.
- an
int
number defines the time as epoch frame - a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.
postproc.end
int, float
default: 1.0
End frame for the post-processing stage. The stage is inactive after this time.
- an
int
number defines the time as epoch frame - a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.
postproc.add
list of length 3 of float
no default
expression variables: learnrate, resolution, time
Adds a fixed value to all pixels.
Three numbers specify red, green and blue while a single number specifies a gray-scale color.
postproc.blur
A gaussian blur is applied to the pixels.
See torchvision gaussian_blur.
postproc.blur.kernel_size
list of length 2 of int
default: [3, 3]
expression variables: learnrate, resolution, time
The size of the pixel window. Must be an odd, positive integer.
Two numbers define width and height separately.
postproc.blur.sigma
list of length 2 of float
no default
expression variables: learnrate, resolution, time
Gaussian kernel standard deviation. The larger, the more blurry.
If not specified it will default to 0.3 * ((kernel_size - 1) * 0.5 - 1) + 0.8
.
Two numbers define sigma for x and y separately.
postproc.border
Draws a border on the edge of the image. The resolution is not changed.
postproc.border.size
list of length 2 of int
default: [1, 1]
expression variables: learnrate, resolution, time
One integer two specify width and height at the same time, or two integers to specify them separately.
postproc.border.color
list of length 3 of float
default: [0.0, 0.0, 0.0]
expression variables: learnrate, resolution, time
The color of the border as float numbers in the range [0, 1]
.
Three numbers for red, green and blue or a single number to specify a gray-scale.
postproc.bwnoise
float
no default
expression variables: learnrate, resolution, time
Adds gray-scale noise to the image.
The noise has a scalable normal distribution around zero.
Specifies the standard deviation of the noise distribution.
postproc.clamp
list of length 2 of float
no default
expression variables: learnrate, resolution, time
Clamps the pixels into a fixed range.
First number is the minimum allowed value for all color channels, second is the maximum allowed value.
An image displayed on screen or converted to a file does only include
values in the range of [0, 1]
.
postproc.edge
This removes everything except edges and generally has a bad effect on image quality. It might be useful, however.
A gaussian blur is used to detect the edges:
edge = amount * abs(image - blur(image))
postproc.edge.kernel_size
list of length 2 of int
default: [3, 3]
expression variables: learnrate, resolution, time
The size of the pixel window used for gaussian blur. Must be an odd, positive integer.
Two numbers define width and height separately.
postproc.edge.sigma
list of length 2 of float
no default
expression variables: learnrate, resolution, time
Gaussian kernel standard deviation. The larger, the more blurry.
If not specified it will default to 0.3 * ((kernel_size - 1) * 0.5 - 1) + 0.8
.
Two numbers define sigma for x and y separately.
postproc.edge.amount
list of length 3 of float
default: [1.0, 1.0, 1.0]
expression variables: learnrate, resolution, time
A multiplier for the edge value. Three numbers to specify red, green and blue separately.
postproc.fnoise
list of length 3 of float
no default
expression variables: learnrate, resolution, time
Adds noise to the image's fourier space.
It's just a bit different than the normal noise.
The noise has a scalable normal distribution around zero.
Specifies the standard deviation of the noise distribution.
The actual value is multiplied by 15.0
to give a visually
similar distribution as the normal noise.
One value or three values to specify red, green and blue separately.
postproc.mean
list of length 3 of float
no default
expression variables: learnrate, resolution, time
Adjust the mean color value.
Three numbers specify red, green and blue while a single number specifies a gray-scale color.
postproc.mul
list of length 3 of float
no default
expression variables: learnrate, resolution, time
Multiplies all pixels by a fixed value.
Three numbers specify red, green and blue while a single number specifies a gray-scale color.
postproc.noise
list of length 3 of float
no default
expression variables: learnrate, resolution, time
Adds noise to the image.
The noise has a scalable normal distribution around zero.
Specifies the standard deviation of the noise distribution.
One value or three values to specify red, green and blue separately.
postproc.random_rotate
Randomly rotates the image.
Degree and center of rotation are chosen randomly between in the range of the specified values.
The resolution is not changed and areas outside of the image are filled with black (zero).
postproc.random_rotate.degree
list of length 2 of float
no default
expression variables: learnrate, resolution, time
The minimum and maximum counter-clockwise angle of ration in degrees.
postproc.random_rotate.center
list of length 2 of float
default: [0.5, 0.5]
expression variables: learnrate, resolution, time
The minimum and maximum center of rotation (for x and y) in the range [0, 1]
.
postproc.random_scale
list of length 2 of float
no default
expression variables: learnrate, resolution, time
Randomly scales an image in the range specified.
The resolution does not change, only contents are scaled. Areas outside of the image are filled with black (zero).
Minimum and maximum scale, where 0.5
means half and 2.0
means double.
postproc.random_shift
list of length 2 or 4 of float
no default
expression variables: learnrate, resolution, time
This randomly translates the pixels of the image.
Pixels that are moved outside get attached on the other side.
Specifies the random range of translation.
A number larger 1 or smaller -1 translates by the actual pixels.
A number between -1 and 1 translates by the fraction of the image resolution.
E.g., shift: 0 1
would randomly translate the image to every possible position
given it's resolution.
Two numbers specify minimum and maximum shift both axis, four numbers specify minimum and maximum shift for axis x and y respectively.
postproc.random_translate
list of length 2 of float
no default
expression variables: learnrate, resolution, time
Randomly translates an image in the specified range.
The resolution does not change. Areas outside of the image are filled with black (zero).
Maximum absolute fraction for horizontal and vertical translations.
For example: random_translate: a, b
, then horizontal shift is randomly sampled in
the range -img_width * a < dx < img_width * a
and vertical shift is randomly sampled in the range
-img_height * b < dy < img_height * b
.
postproc.rnoise
Adds noise with a different resolution to the image.
The noise has a scalable normal distribution around zero.
postproc.rnoise.std
list of length 3 of float
no default
expression variables: learnrate, resolution, time
Specifies the standard deviation of the noise distribution.
One value or three values to specify red, green and blue separately.
postproc.rnoise.resolution
list of length 2 of int
no default
expression variables: learnrate, resolution, time
The resolution of the noise image. It will be resized to the processed image.
postproc.rotate
Rotates the image.
The resolution is not changed and areas outside of the image are filled with black (zero).
postproc.rotate.degree
float
no default
expression variables: learnrate, resolution, time
The counter-clockwise angle of ration in degrees ([0, 360]
).
postproc.rotate.center
list of length 2 of float
default: [0.5, 0.5]
expression variables: learnrate, resolution, time
The center of rotation in the range [0, 1]
.
Two numbers to specify x and y separately.
postproc.shift
list of length 2 of float
no default
expression variables: learnrate, resolution, time
This translates the image while wrapping the edges around.
Pixels that are moved outside get attached on the other side.
A number larger 1 or smaller -1 translates by the actual pixels.
A number between -1 and 1 translates by the fraction of the image resolution.
E.g., shift: .5
would move the center of the image to the previous bottom-right
corner.
A single number specifies translation on both x and y axes while two numbers specify them separately.
targets.constraints
Constraints do influence the trained image without using CLIP.
They only affect the pixels that are processed by the transforms of the target.
targets.constraints.blur
Adds the difference between the image and a blurred version to the training loss.
This is much more helpful than using the gaussian blur as a post-processing step. When added to the training loss, the blurring keeps in balance with the actual image creation.
Areas that CLIP is excited about will be constantly updated and will stand out of the blur, while unexciting areas get blurred a lot.
targets.constraints.blur.kernel_size
list of length 2 of int
default: [3, 3]
expression variables: learnrate, resolution, target constraint, time
The size of the pixel window. Must be an odd, positive integer.
Two numbers define width and height separately.
targets.constraints.blur.sigma
list of length 2 of float
no default
expression variables: learnrate, resolution, target constraint, time
Gaussian kernel standard deviation. The larger, the more blurry.
If not specified it will default to 0.3 * ((kernel_size - 1) * 0.5 - 1) + 0.8
.
Two numbers define sigma for x and y separately.
targets.constraints.blur.weight
float
default: 1.0
expression variables: learnrate, resolution, target constraint, time
A multiplier for the resulting loss value of the constraint.
targets.constraints.blur.start
int, float
default: 0.0
expression variables: learnrate, resolution, target constraint, time
Start frame of the constraints. The constraint is inactive before this time.
- an
int
number defines the time as epoch frame - a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.an
int
number defines the time as epoch frame- a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.
targets.constraints.blur.end
int, float
default: 1.0
expression variables: learnrate, resolution, target constraint, time
End frame of the constraints. The constraint is inactive after this time.
- an
int
number defines the time as epoch frame - a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.an
int
number defines the time as epoch frame- a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.
targets.constraints.blur.loss
str
default: l2
expression variables: learnrate, resolution, target constraint, time
The loss function used to calculate the difference (or error) between current and desired image.
l1
ormae
: Mean absolute error is the mean of the absolute difference of each vector variable.l2
ormse
: Mean squared error is the mean of the squared difference of each vector variable. Compared to mean absolute error, it produces a smaller loss for small differences (below 1.0) and a larger loss for large differences.
targets.constraints.border
Adds a border with a specific size and color to the training loss.
targets.constraints.border.size
list of length 2 of int
default: [1, 1]
expression variables: learnrate, resolution, target constraint, time
One integer two specify width and height at the same time, or two integers to specify them separately.
targets.constraints.border.color
list of length 3 of float
default: [0.0, 0.0, 0.0]
expression variables: learnrate, resolution, target constraint, time
The color of the border as float numbers in the range [0, 1]
.
Three numbers for red, green and blue or a single number to specify a gray-scale.
targets.constraints.border.weight
float
default: 1.0
expression variables: learnrate, resolution, target constraint, time
A multiplier for the resulting loss value of the constraint.
targets.constraints.border.start
int, float
default: 0.0
expression variables: learnrate, resolution, target constraint, time
Start frame of the constraints. The constraint is inactive before this time.
- an
int
number defines the time as epoch frame - a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.an
int
number defines the time as epoch frame- a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.
targets.constraints.border.end
int, float
default: 1.0
expression variables: learnrate, resolution, target constraint, time
End frame of the constraints. The constraint is inactive after this time.
- an
int
number defines the time as epoch frame - a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.an
int
number defines the time as epoch frame- a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.
targets.constraints.border.loss
str
default: l2
expression variables: learnrate, resolution, target constraint, time
The loss function used to calculate the difference (or error) between current and desired image.
l1
ormae
: Mean absolute error is the mean of the absolute difference of each vector variable.l2
ormse
: Mean squared error is the mean of the squared difference of each vector variable. Compared to mean absolute error, it produces a smaller loss for small differences (below 1.0) and a larger loss for large differences.
targets.constraints.contrast
Pushes the contrast above or below a threshold value.
The contrast is currently calculated in the following way:
The image pixels are divided into the ones that are above and below the pixel mean values. The contrast value is then the difference between the mean of the lower and the mean of the higher pixels.
targets.constraints.contrast.above
list of length 3 of float
no default
expression variables: learnrate, resolution, target constraint, time
If specified, the training loss increases if the current value is
below the above
value.
targets.constraints.contrast.below
list of length 3 of float
no default
expression variables: learnrate, resolution, target constraint, time
If specified, the training loss increases if the current value is
above the below
value.
targets.constraints.contrast.weight
float
default: 1.0
expression variables: learnrate, resolution, target constraint, time
A multiplier for the resulting loss value of the constraint.
targets.constraints.contrast.start
int, float
default: 0.0
expression variables: learnrate, resolution, target constraint, time
Start frame of the constraints. The constraint is inactive before this time.
- an
int
number defines the time as epoch frame - a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.an
int
number defines the time as epoch frame- a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.
targets.constraints.contrast.end
int, float
default: 1.0
expression variables: learnrate, resolution, target constraint, time
End frame of the constraints. The constraint is inactive after this time.
- an
int
number defines the time as epoch frame - a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.an
int
number defines the time as epoch frame- a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.
targets.constraints.contrast.loss
str
default: l2
expression variables: learnrate, resolution, target constraint, time
The loss function used to calculate the difference (or error) between current and desired image.
l1
ormae
: Mean absolute error is the mean of the absolute difference of each vector variable.l2
ormse
: Mean squared error is the mean of the squared difference of each vector variable. Compared to mean absolute error, it produces a smaller loss for small differences (below 1.0) and a larger loss for large differences.
targets.constraints.edge_mean
Adds the difference between the current image and and an edge-detected version to the training loss.
A gaussian blur is used to detect the edges:
edge = amount * abs(image - blur(image))
targets.constraints.edge_mean.above
list of length 3 of float
no default
expression variables: learnrate, resolution, target constraint, time
If specified, the training loss increases if the current value is
below the above
value.
targets.constraints.edge_mean.below
list of length 3 of float
no default
expression variables: learnrate, resolution, target constraint, time
If specified, the training loss increases if the current value is
above the below
value.
targets.constraints.edge_mean.weight
float
default: 1.0
expression variables: learnrate, resolution, target constraint, time
A multiplier for the resulting loss value of the constraint.
targets.constraints.edge_mean.start
int, float
default: 0.0
expression variables: learnrate, resolution, target constraint, time
Start frame of the constraints. The constraint is inactive before this time.
- an
int
number defines the time as epoch frame - a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.an
int
number defines the time as epoch frame- a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.
targets.constraints.edge_mean.end
int, float
default: 1.0
expression variables: learnrate, resolution, target constraint, time
End frame of the constraints. The constraint is inactive after this time.
- an
int
number defines the time as epoch frame - a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.an
int
number defines the time as epoch frame- a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.
targets.constraints.edge_mean.loss
str
default: l2
expression variables: learnrate, resolution, target constraint, time
The loss function used to calculate the difference (or error) between current and desired image.
l1
ormae
: Mean absolute error is the mean of the absolute difference of each vector variable.l2
ormse
: Mean squared error is the mean of the squared difference of each vector variable. Compared to mean absolute error, it produces a smaller loss for small differences (below 1.0) and a larger loss for large differences.
targets.constraints.edge_mean.kernel_size
list of length 2 of int
default: [3, 3]
expression variables: learnrate, resolution, target constraint, time
The size of the pixel window of the gaussian blur. Must be an odd, positive integer.
Two numbers define width and height separately.
targets.constraints.edge_mean.sigma
list of length 2 of float
no default
expression variables: learnrate, resolution, target constraint, time
Gaussian kernel standard deviation. The larger, the more blurry.
If not specified it will default to 0.3 * ((kernel_size - 1) * 0.5 - 1) + 0.8
.
Two numbers define sigma for x and y separately.
targets.constraints.mean
Pushes the image color mean above or below a threshold value.
targets.constraints.mean.above
list of length 3 of float
no default
expression variables: learnrate, resolution, target constraint, time
If specified, the training loss increases if the current value is
below the above
value.
targets.constraints.mean.below
list of length 3 of float
no default
expression variables: learnrate, resolution, target constraint, time
If specified, the training loss increases if the current value is
above the below
value.
targets.constraints.mean.weight
float
default: 1.0
expression variables: learnrate, resolution, target constraint, time
A multiplier for the resulting loss value of the constraint.
targets.constraints.mean.start
int, float
default: 0.0
expression variables: learnrate, resolution, target constraint, time
Start frame of the constraints. The constraint is inactive before this time.
- an
int
number defines the time as epoch frame - a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.an
int
number defines the time as epoch frame- a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.
targets.constraints.mean.end
int, float
default: 1.0
expression variables: learnrate, resolution, target constraint, time
End frame of the constraints. The constraint is inactive after this time.
- an
int
number defines the time as epoch frame - a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.an
int
number defines the time as epoch frame- a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.
targets.constraints.mean.loss
str
default: l2
expression variables: learnrate, resolution, target constraint, time
The loss function used to calculate the difference (or error) between current and desired image.
l1
ormae
: Mean absolute error is the mean of the absolute difference of each vector variable.l2
ormse
: Mean squared error is the mean of the squared difference of each vector variable. Compared to mean absolute error, it produces a smaller loss for small differences (below 1.0) and a larger loss for large differences.
targets.constraints.noise
Adds the difference between the current image and a noisy image to the training loss.
targets.constraints.noise.std
list of length 3 of float
no default
expression variables: learnrate, resolution, target constraint, time
Specifies the standard deviation of the noise distribution.
One value or three values to specify red, green and blue separately.
targets.constraints.noise.weight
float
default: 1.0
expression variables: learnrate, resolution, target constraint, time
A multiplier for the resulting loss value of the constraint.
targets.constraints.noise.start
int, float
default: 0.0
expression variables: learnrate, resolution, target constraint, time
Start frame of the constraints. The constraint is inactive before this time.
- an
int
number defines the time as epoch frame - a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.an
int
number defines the time as epoch frame- a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.
targets.constraints.noise.end
int, float
default: 1.0
expression variables: learnrate, resolution, target constraint, time
End frame of the constraints. The constraint is inactive after this time.
- an
int
number defines the time as epoch frame - a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.an
int
number defines the time as epoch frame- a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.
targets.constraints.noise.loss
str
default: l2
expression variables: learnrate, resolution, target constraint, time
The loss function used to calculate the difference (or error) between current and desired image.
l1
ormae
: Mean absolute error is the mean of the absolute difference of each vector variable.l2
ormse
: Mean squared error is the mean of the squared difference of each vector variable. Compared to mean absolute error, it produces a smaller loss for small differences (below 1.0) and a larger loss for large differences.
targets.constraints.normalize
Adds image normalization to the training loss.
The normalized version is found by moving the image colors into the range of min and max.
targets.constraints.normalize.min
list of length 3 of float
default: [0.0, 0.0, 0.0]
expression variables: learnrate, resolution, target constraint, time
The desired lowest value in the image.
One color for gray-scale, three colors for red, green and blue.
targets.constraints.normalize.max
list of length 3 of float
default: [1.0, 1.0, 1.0]
expression variables: learnrate, resolution, target constraint, time
The desired highest value in the image.
One color for gray-scale, three colors for red, green and blue.
targets.constraints.normalize.weight
float
default: 1.0
expression variables: learnrate, resolution, target constraint, time
A multiplier for the resulting loss value of the constraint.
targets.constraints.normalize.start
int, float
default: 0.0
expression variables: learnrate, resolution, target constraint, time
Start frame of the constraints. The constraint is inactive before this time.
- an
int
number defines the time as epoch frame - a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.an
int
number defines the time as epoch frame- a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.
targets.constraints.normalize.end
int, float
default: 1.0
expression variables: learnrate, resolution, target constraint, time
End frame of the constraints. The constraint is inactive after this time.
- an
int
number defines the time as epoch frame - a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.an
int
number defines the time as epoch frame- a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.
targets.constraints.normalize.loss
str
default: l2
expression variables: learnrate, resolution, target constraint, time
The loss function used to calculate the difference (or error) between current and desired image.
l1
ormae
: Mean absolute error is the mean of the absolute difference of each vector variable.l2
ormse
: Mean squared error is the mean of the squared difference of each vector variable. Compared to mean absolute error, it produces a smaller loss for small differences (below 1.0) and a larger loss for large differences.
targets.constraints.saturation
Pushes the saturation above or below a threshold value.
The saturation is currently calculated as the difference of each color channel to the mean of all channels.
targets.constraints.saturation.above
list of length 3 of float
no default
expression variables: learnrate, resolution, target constraint, time
If specified, the training loss increases if the current value is
below the above
value.
targets.constraints.saturation.below
list of length 3 of float
no default
expression variables: learnrate, resolution, target constraint, time
If specified, the training loss increases if the current value is
above the below
value.
targets.constraints.saturation.weight
float
default: 1.0
expression variables: learnrate, resolution, target constraint, time
A multiplier for the resulting loss value of the constraint.
targets.constraints.saturation.start
int, float
default: 0.0
expression variables: learnrate, resolution, target constraint, time
Start frame of the constraints. The constraint is inactive before this time.
- an
int
number defines the time as epoch frame - a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.an
int
number defines the time as epoch frame- a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.
targets.constraints.saturation.end
int, float
default: 1.0
expression variables: learnrate, resolution, target constraint, time
End frame of the constraints. The constraint is inactive after this time.
- an
int
number defines the time as epoch frame - a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.an
int
number defines the time as epoch frame- a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.
targets.constraints.saturation.loss
str
default: l2
expression variables: learnrate, resolution, target constraint, time
The loss function used to calculate the difference (or error) between current and desired image.
l1
ormae
: Mean absolute error is the mean of the absolute difference of each vector variable.l2
ormse
: Mean squared error is the mean of the squared difference of each vector variable. Compared to mean absolute error, it produces a smaller loss for small differences (below 1.0) and a larger loss for large differences.
targets.constraints.std
Pushes the standard deviation above or below a threshold value.
targets.constraints.std.above
list of length 3 of float
no default
expression variables: learnrate, resolution, target constraint, time
If specified, the training loss increases if the current value is
below the above
value.
targets.constraints.std.below
list of length 3 of float
no default
expression variables: learnrate, resolution, target constraint, time
If specified, the training loss increases if the current value is
above the below
value.
targets.constraints.std.weight
float
default: 1.0
expression variables: learnrate, resolution, target constraint, time
A multiplier for the resulting loss value of the constraint.
targets.constraints.std.start
int, float
default: 0.0
expression variables: learnrate, resolution, target constraint, time
Start frame of the constraints. The constraint is inactive before this time.
- an
int
number defines the time as epoch frame - a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.an
int
number defines the time as epoch frame- a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.
targets.constraints.std.end
int, float
default: 1.0
expression variables: learnrate, resolution, target constraint, time
End frame of the constraints. The constraint is inactive after this time.
- an
int
number defines the time as epoch frame - a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.an
int
number defines the time as epoch frame- a
float
number defines the time as ratio between 0.0 and 1.0, where 1.0 is the final epoch. percent
(e.g.23.5%
) defines the time as percentage of the number of epochs.
targets.constraints.std.loss
str
default: l2
expression variables: learnrate, resolution, target constraint, time
The loss function used to calculate the difference (or error) between current and desired image.
l1
ormae
: Mean absolute error is the mean of the absolute difference of each vector variable.l2
ormse
: Mean squared error is the mean of the squared difference of each vector variable. Compared to mean absolute error, it produces a smaller loss for small differences (below 1.0) and a larger loss for large differences.


error-handler.js
Handles errors caught by Node.JS. Prints user-friendly error messages.
- Source:
Methods
(inner) errorCallback(err)
Function that is called when Node.JS experiences an error.
Catches the following errors:
Catches the following errors:
- EADDRINUSE
- ENOENT
Parameters:
| Name | Type | Description |
|---|---|---|
err |
Error | Node.JS error |
- Source:


Source: https://sharov43.livejournal.com/1357995.html
— interactive analytic queries;
— on constantly appended data.
«Double realtime»
The most valuable feature of ClickHouse — it's speed.
2008 — first commits in codebase;
2010 — start of research and development;
2012 — use in production for some tasks;
2014 — use in production as core service technology;
2015 — widespread inside Yandex;
2016 — released in open-source!
Now — more than 1000 companies are using ClickHouse.
2008 — first commits in codebase;
I was a developer of Yandex.Metrica service.
I had neither ideas or plans about ClickHouse
but some commits are dated back then.
2008 — first commits in codebase;
2010 — start of research and development;
As an experimental side project.
We have tested multiple existing solutions (as of 2010):
MonetDB, Infobright, InfiniDB...
2008 — first commits in codebase;
2010 — start of research and development;
Nothing was good enough.
Hypothesis:
If we have good enough column-oriented DBMS,
we could store all our data in non-aggregated form
(raw pageviews and sessions) and generate all the reports on the fly,
to allow infinite customization.
This is how "traditional" row-oriented databases work:
And this is how column-oriented databases work:
2008 — first commits in codebase;
2010 — start of research and development;
2012 — use in production for some tasks;
(for intermediate data processing)
2008 — first commits in codebase;
2010 — start of research and development;
2012 — use in production for some data processing tasks;
2014 — use in production as core service technology;
(for realtime reporting)
The hypothesis was proved!
* If you want to try ClickHouse, one server or VM is enough.
2008 — first commits in codebase;
2010 — start of research and development;
2012 — use in production for some tasks;
2014 — use in production as core service technology;
2015 — widespread inside Yandex;
In multiple departments: search, e-commerce, advertisement, personalized news, infrastructure, NOC, business analytics...
2008 — first commits in codebase;
2010 — start of research and development;
2012 — use in production for some tasks;
2014 — use in production as core service technology;
2015 — widespread inside Yandex;
2016 — released in open-source!
2008 — first commits in codebase;
2010 — start of research and development;
2012 — use in production for some tasks;
2014 — use in production as core service technology;
2015 — widespread inside Yandex;
2016 — released in open-source!
Now — more than 1000 companies are using ClickHouse.
Press here please :) ---^
1. Development and support for use cases in our company (Yandex).
2. Maximum widespread of ClickHouse as open-source product.
Rules of successful open-source:
— the product must solve actual problem;
— and do it better than others.
Our goal:
ClickHouse must be the default choice
as an open-source analytical DBMS
— the first and the only right solution
for appropriate use cases;
— and everyone should be aware of it :)
No time to celebrate.
— VK;
— nVidia;
— Spotify;
— Yandex;
— Amadeus;
— Bloomberg;
— CloudFlare;
— ContentSquare;
— Deutsche Bank;
— A-word fruit company;
— C-word telecom company;
— e-word ecommerce company;
— National payment system of (undisclosed) country.
— JD;
— Sina;
— Tencent;
— ByteDance;
— KuaiShou;
— Analysys;
— QingCloud;
— OneAPM;
— HUYA Internet;
... your company?
ClickHouse
не тормозит
ClickHouse
is not slow*
We really need it.
Yandex.Metrica must work!
High level architecture:
— Scale-out shared nothing;
— Massive Parallel Processing;
Data storage optimizations:
— Column-oriented storage;
— Merge Tree;
— Sparse index;
— Data compression;
Algorithmic optimizations:
Best algorithms in the world...
... are happy to be used in ClickHouse.
— Volnitsky substring search
— Hyperscan and RE2
— SIMD JSON
— HDR Histograms
— Roaring Bitmaps
...
Low-level optimizations:
Optimizations for CPU instruction sets
using SIMD processing.
— SIMD text parsing
— SIMD data filtering
— SIMD decompression
— SIMD string operations
...
Specializations of algorithms...
... and attention to detail:
— uniq, uniqExact, uniqCombined, uniqUpTo;
— quantile, quantileTiming, quantileExact, quantileTDigest, quantileWeighted;
— 40+ specializations of GROUP BY;
— algorithms optimize itself for data distribution:
LZ4 decompression with Bayesian Bandits.
— better product quality;
— better Yandex representation as tech company;
— for hiring developers more easily;
— motivation of developers;
Drawbacks:
— it's hard work;
— and we're working really a lot;
HTTP REST
clickhouse-client
JDBC, ODBC
(new) MySQL protocol compatibility
Python, PHP, Perl, Go,
Node.js, Ruby, C++, .NET, Scala, R, Julia, Rust
Web site: https://clickhouse.com/
GitHub: https://github.com/ClickHouse/ClickHouse/
Maillist<EMAIL_ADDRESS>Wechat: 4 groups (ask your friend to invite)
+ meetups. Moscow, Saint-Petersburg, Novosibirsk, Ekaterinburg, Minsk...
... Berlin, Paris, Amsterdam, Madrid, Munich, San-Francisco,
... Beijing, Shenzhen, Shanghai, Hong Kong, Singapore, Tokyo.


Bikers.in
Studds
Rs. 970
SteelBird
Rs. 1130
Al RIM
Rs. 970
Mg RIM
Rs. 1130
BrakeLever 1
Rs. 970
BrakeLever 2
Rs. 1130
Motul
Rs. 970
Yamalube
Rs. 1130
LED Indicator 1
Rs. 970
LED Indicator 2
Rs. 1130
Footrest 1
Rs. 970
Footrest 2
Rs. 1130
ITEM
PRICE
QUANTITY
Total
0


No special actions required, all sites you make with Mobirise are mobile-friendly. You don't have to create a special mobile version of your site, it will adapt automagically.
Mobirise is an easy website builder - just drop site elements to your page, add content and style it to look the way you like.
Mobirise offers many site blocks in several themes, and though these blocks are pre-made, they are flexible. You can combine blocks in different ways on your pages.
Mobirise gives you the freedom to develop as many websites as you like given the fact that it is a desktop app.
Mobirise is an offline app for Window and Mac to easily create small/medium websites, landing pages, online resumes and portfolios, promo sites for apps, events, services and products.
Mobirise is perfect for non-techies who are not familiar with the intricacies of web development and for designers who prefer to work as visually as possible, without fighting with code. Also great for pro-coders for fast prototyping and small customers' projects.
Key differences from traditional builders:
* Minimalistic, extremely easy-to-use interface
* Mobile-friendliness, latest website blocks and techniques "out-the-box"
* Free for commercial and non-profit use


Ted Kremenek, kremenek at apple
Zhongxing Xu, xuzhongzhing at gmail
The path-sensitive analysis engine in libAnalysis employs an extensible API for abstractly modeling the memory of an analyzed program. This API employs the concept of "memory regions" to abstractly model chunks of program memory such as program variables and dynamically allocated memory such as those returned from 'malloc' and 'alloca'. Regions are hierarchical, with subregions modeling subtyping relationships, field and array offsets into larger chunks of memory, and so on.
The region API consists of two components:
Symbolic stores, which can be thought of as representing the relation regions -> values, are implemented by subclasses of the StoreManager class (Store.h). A particular StoreManager implementation has complete flexibility concerning the following:
Together, both points allow different StoreManagers to tradeoff between different levels of analysis precision and scalability concerning the reasoning of program memory. Meanwhile, the core path-sensitive engine makes no assumptions about either points, and queries a StoreManager about the bindings to a memory region through a generic interface that all StoreManagers share. If a particular StoreManager cannot reason about the potential bindings of a given memory region (e.g., 'BasicStoreManager' does not reason about fields of structures) then the StoreManager can simply return 'unknown' (represented by 'UnknownVal') for a particular region-binding. This separation of concerns not only isolates the core analysis engine from the details of reasoning about program memory but also facilities the option of a client of the path-sensitive engine to easily swap in different StoreManager implementations that internally reason about program memory in very different ways.
The rest of this document is divided into two parts. We first discuss region taxonomy and the semantics of regions. We then discuss the StoreManager interface, and details of how the currently available StoreManager classes implement region bindings.
Before talking about the memory regions, we would talk about the pointers since memory regions are essentially used to represent pointer values.
The pointer is a type of values. Pointer values have two semantic aspects. One is its physical value, which is an address or location. The other is the type of the memory object residing in the address.
Memory regions are designed to abstract these two properties of the pointer. The physical value of a pointer is represented by MemRegion pointers. The rvalue type of the region corresponds to the type of the pointee object.
One complication is that we could have different view regions on the same memory chunk. They represent the same memory location, but have different abstract location, i.e., MemRegion pointers. Thus we need to canonicalize the abstract locations to get a unique abstract location for one physical location.
Furthermore, these different view regions may or may not represent memory objects of different types. Some different types are semantically the same, for example, 'struct s' and 'my_type' are the same type.
struct s; typedef struct s my_type;
But char and int are not the same type in the code below:
void *p; int *q = (int*) p; char *r = (char*) p;Thus we need to canonicalize the MemRegion which is used in binding and retrieving.
Region is the entity used to model pointer values. A Region has the following properties:
A symbolic region is a map of the concept of symbolic values into the domain of regions. It is the way that we represent symbolic pointers. Whenever a symbolic pointer value is needed, a symbolic region is created to represent it.
A symbolic region has no type. It wraps a SymbolData. But sometimes we have type information associated with a symbolic region. For this case, a TypedViewRegion is created to layer the type information on top of the symbolic region. The reason we do not carry type information with the symbolic region is that the symbolic regions can have no type. To be consistent, we don't let them to carry type information.
Like a symbolic pointer, a symbolic region may be NULL, has unknown extent, and represents a generic chunk of memory.
NOTE: We plan not to use loc::SymbolVal in RegionStore and remove it gradually.
Symbolic regions get their rvalue types through the following ways:
void f(struct s* p) { ... }
The symbolic region pointed to by p has type struct s.
void f(void* p) { struct s* q = (struct s*) p; ... }
We attach the type information to the symbolic region lazily. For the first case above, we create the TypedViewRegion only when the pointer is actually used to access the pointee memory object, that is when the element or field region is created. For the cast case, the TypedViewRegion is created when visiting the CastExpr.
The reason for doing lazy typing is that symbolic regions are sometimes only used to do location comparison.
Pointer casts allow people to impose different 'views' onto a chunk of memory.
Usually we have two kinds of casts. One kind of casts cast down with in the type hierarchy. It imposes more specific views onto more generic memory regions. The other kind of casts cast up with in the type hierarchy. It strips away more specific views on top of the more generic memory regions.
We simulate the down casts by layering another TypedViewRegion on top of the original region. We simulate the up casts by striping away the top TypedViewRegion. Down casts is usually simple. For up casts, if the there is no TypedViewRegion to be stripped, we return the original region. If the underlying region is of the different type than the cast-to type, we flag an error state.
For toll-free bridging casts, we return the original region.
We can set up a partial order for pointer types, with the most general type void* at the top. The partial order forms a tree with void* as its root node.
Every MemRegion has a root position in the type tree. For example, the pointee region of void *p has its root position at the root node of the tree. VarRegion of int x has its root position at the 'int type' node.
TypedViewRegion is used to move the region down or up in the tree. Moving down in the tree adds a TypedViewRegion. Moving up in the tree removes a TypedViewRegion.
Do we want to allow moving up beyond the root position? This happens when:
int x; void *p = &x;
The region of x has its root position at 'int*' node. the cast to void* moves that region up to the 'void*' node. I propose to not allow such casts, and assign the region of x for p.
The following region kinds are boundable: VarRegion, CompoundLiteralRegion, StringRegion, ElementRegion, FieldRegion, and ObjCIvarRegion.
When binding regions, we perform canonicalization on element regions and field regions. This is because we can have different views on the same region, some of which are essentially the same view with different sugar type names.
To canonicalize a region, we get the canonical types for all TypedViewRegions along the way up to the root region, and make new TypedViewRegions with those canonical types.
For Objective-C and C++, perhaps another canonicalization rule should be added: for FieldRegion, the least derived class that has the field is used as the type of the super region of the FieldRegion.
All bindings and retrievings are done on the canonicalized regions.
Canonicalization is transparent outside the region store manager, and more specifically, unaware outside the Bind() and Retrieve() method. We don't need to consider region canonicalization when doing pointer cast.
The constraint manager reasons about the abstract location of memory objects. We can have different views on a region, but none of these views changes the location of that object. Thus we should get the same abstract location for those regions.


This page serves as a basic skeleton for web apps such as Pareto Anywhere Apps.
The following table specifies assignments for events.
| Icon | class | Assignment |
|---|---|---|
fas fa-exchange-alt |
Events | |
fas fa-sign-in-alt |
Appearance event | |
fas fa-route |
Displacement event | |
fas fa-info |
Packets event | |
fas fa-heartbeat |
Keep-Alive event | |
fas fa-sign-out-alt |
Disappearance event |
The following table specifies assignments for raddecs.
| Icon | class | Assignment |
|---|---|---|
fas fa-barcode |
transmitterId | |
fas fa-map-pin |
receiverId | |
fas fa-info-circle |
transmitterIdType & receiverIdType | |
fas fa-signal |
rssi | |
fas fa-clock |
timestamp | |
fas fa-exchange-alt |
events |
The following table specifies assignments for filters.
| Icon | class | Assignment |
|---|---|---|
fas fa-filter |
ID filter and such | |
fas fa-sort |
Sort by | |
fas fa-eye |
Displaying | |
fas fa-scroll |
Query template |
The following iconography informs about the purpose, technology, accountability and data retention of the digital systems present in the physical space.
Visit dtpr.io for more information.


Calculating background statistics¶
-
odi_helpers.
bkg_boxes
(hdu, nboxes, length, sources)[source]¶ Function to calculate the sigma clipped statistics of a number of randomly generated boxes over an ota.
Parameters: - hdu (fits object) – Hdulist that as been opened by astropy.fits.io
- nboxes (int) – Number of random boxes to generate over the ota
- length (int) – Length of side of box in pixels
- sources (bool) – If
True
any sources detected in a given box will be masked before calculating the background statistics
Returns: - bg_stats (numpy array) – Array containing the background stats of all of the boxes
- bg_median (float) – Median background level of the boxes
- med_std (float) – Median standard deviation of the background level in each box
- std_std (float) – Standard deviation of the standard deviations in each box
- centers (list) – Pixel centers of each box


This store brings you great app bundles week after week. We select the best power user apps from a broad range of suppliers and combine them into great deals. These are the highest quality apps from the best publishers, at great prices.
Whether you are interested in gaming or graphics design, software development or media production - we have the bundle for you. Each app bundle is designed to compliment the others, delivering you an exciting take on a scene.
Our guarantee: at the store, we're committed to providing you, with an exceptional quality and reliability. Every application is checked in detail for stability, usability and inter-interoperability. If you are unhappy with any individual app in a bundle we will refund you the full amount for the complete suite, no questions asked.
Favourites
These are some of our favourites
We will be reviewing these favourites in the coming weeks, so please check in again to find out why these are our favourite apps.
 Directions are included below.


Soldering Safety & Tips
Never touch the tip!
Do not hold items in hand while soldering.
Clean tip on sponge or wool regularly.
Return soldering iron to stand when not in use.
Turn off soldering iron.
Always wash your hands after soldering.


The heaviness measures the number of additional dependency packages that a parent package uniquely imports, which are the dependency packages not imported by any of the other parent packages. However, there are scenarios when multiple parents import similar sets of dependencies, which results in heaviness for individual parent being very small.
We take the DESeq2 package (version 1.36.0) as an example. First we generate the dependency heatmap.
You can drag the plot into a new tab if it is too small to read.
# or create the plot in an HTML page
# dependency_report(x)
As can be observed from the heatmap, DESeq2’s two parents geneplotter and genefilter (the last two rows in “Imports” category in the heatmap) import 51 and 53 dependency packages, among them 50 packages are the same. Due to the high overlap, the heaviness of geneplotter and genefilter on DESeq2 are only 1 and 2 respectively. However, if taking the two parents together, i.e., by moving both parents to “Suggests” of DESeq2, 23 dependency packages can be reduced.
Here we define the co-heaviness that measures the number of additional dependency packages brought by two parent packages. Denote a package as P and its two strong parent packages as A and B, i.e., parent packages in “Depends”, “Imports” and “LinkingTo”, denote \(S_A\) as the set of reduced dependency packages when only moving A to “Suggests” of P, denote \(S_B\) as the set of reduced dependency packages when only moving B to “Suggests” of P, and denote \(S_{AB}\) as the set of reduced dependency packages when moving A and B together to “Suggests” of P, the co-heaviness of A, B on P is calculatd as
\[ \left | S_{AB} \setminus \cup (S_A, S_B) \right | \]
which is the number of reduced package only caused by co-action of A and B. Symbol \(A \setminus B\) is the set of elements in A not in B and \(|A|\) is the number of elements in set A.
Denote \(h_A\) as the heaviness of A (as a strong parent) on P, \(h_B\) as the heaviness of B (as a strong parent) on P, and \(h_{AB}\) as the co-heaviess of A/B on P, the number of reduced strong dependencies by moving both A and B to P’s “Suggests” is:
\[ h_A + h_B + h_{AB} \]
pkgndep provides a function co_heaviness()
that calculates co-heaviness of two parent packages. It returns a co-heaviness matrix. Please note it only returns the matrix for strong parents.
m = co_heaviness(x)
m
## S4Vectors IRanges GenomicRanges SummarizedExperiment
## S4Vectors 0 0 0 0
## IRanges 0 0 0 0
## GenomicRanges 0 0 0 1
## SummarizedExperiment 0 0 1 4
## methods 0 0 0 0
## stats4 0 0 0 0
## Rcpp 0 0 0 0
## BiocGenerics 0 0 0 0
## Biobase 0 0 0 0
## locfit 0 0 0 0
## BiocParallel 0 0 0 0
## ggplot2 0 0 0 0
## geneplotter 0 0 0 0
## genefilter 0 0 0 0
## RcppArmadillo 0 0 0 0
## methods stats4 Rcpp BiocGenerics Biobase locfit
## S4Vectors 0 0 0 0 0 0
## IRanges 0 0 0 0 0 0
## GenomicRanges 0 0 0 0 0 0
## SummarizedExperiment 0 0 0 0 0 0
## methods 0 0 0 0 0 0
## stats4 0 0 0 0 0 0
## Rcpp 0 0 0 0 0 0
## BiocGenerics 0 0 0 0 0 0
## Biobase 0 0 0 0 0 0
## locfit 0 0 0 0 0 1
## BiocParallel 0 0 0 0 0 0
## ggplot2 0 0 0 0 0 0
## geneplotter 0 0 0 0 0 0
## genefilter 0 0 0 0 0 0
## RcppArmadillo 0 0 0 0 0 0
## BiocParallel ggplot2 geneplotter genefilter RcppArmadillo
## S4Vectors 0 0 0 0 0
## IRanges 0 0 0 0 0
## GenomicRanges 0 0 0 0 0
## SummarizedExperiment 0 0 0 0 0
## methods 0 0 0 0 0
## stats4 0 0 0 0 0
## Rcpp 0 0 0 0 0
## BiocGenerics 0 0 0 0 0
## Biobase 0 0 0 0 0
## locfit 0 0 0 0 0
## BiocParallel 9 0 0 0 0
## ggplot2 0 21 1 1 0
## geneplotter 0 1 1 23 0
## genefilter 0 1 23 2 0
## RcppArmadillo 0 0 0 0 1
## attr(,"max")
## [1] 23
## attr(,"max_pair")
## [1] "genefilter" "geneplotter"
The co-heaviness matrix can be visualized as a heatmap.
library(ComplexHeatmap)
Heatmap(m, name = "co-heaviness")
There are two major reasons for the high co-heaviness from two parent packages. 1. Parent A also depends on package B, thus all the dependency packages brought by package B will also be included in the dependency packages from package A. E.g., package ffpe’s two parents lumi and methylumi where lumi also depends on methylumi and most of the heaviness comes from methylummi. 2. Although A and B do not depend on each other, they have a common upstream package, which brings the same dependencies to A and B. Such as the example of DESeq2, its two parent packages geneplotter and genefilter have a common upstream pacakge annotate that contribute many dependencies to both package.
Alternatively, the co-heaviness can also be defined as a relative measure, the Jaccard coeffcient. Note \(S_{AB} \setminus \cup (S_A, S_B)\) is actually the set of dependencies that are imported simultaneously by and only by two parent packages A and B. Thus the Jaccard coeffcient is calculated as:
\[ \frac{ \left | S_{AB} \setminus \cup (S_A, S_B) \right | }{ \left | S_{AB} \right | } \]
Or using the denotation of heaviness defined before, the Jaccard coeffcient can also be written as:
\[ \frac{h_{AB}}{h_A + h_B + h_{AB}} \]
The Jaccard coeffcient can be calculated by setting argument jaccard = TRUE
:
co_heaviness(x, jaccard = TRUE)
## S4Vectors IRanges GenomicRanges SummarizedExperiment
## S4Vectors 0 0 0.0 0.0
## IRanges 0 0 0.0 0.0
## GenomicRanges 0 0 0.0 0.2
## SummarizedExperiment 0 0 0.2 1.0
## methods 0 0 0.0 0.0
## stats4 0 0 0.0 0.0
## Rcpp 0 0 0.0 0.0
## BiocGenerics 0 0 0.0 0.0
## Biobase 0 0 0.0 0.0
## locfit 0 0 0.0 0.0
## BiocParallel 0 0 0.0 0.0
## ggplot2 0 0 0.0 0.0
## geneplotter 0 0 0.0 0.0
## genefilter 0 0 0.0 0.0
## RcppArmadillo 0 0 0.0 0.0
## methods stats4 Rcpp BiocGenerics Biobase locfit
## S4Vectors 0 0 0 0 0 0
## IRanges 0 0 0 0 0 0
## GenomicRanges 0 0 0 0 0 0
## SummarizedExperiment 0 0 0 0 0 0
## methods 0 0 0 0 0 0
## stats4 0 0 0 0 0 0
## Rcpp 0 0 0 0 0 0
## BiocGenerics 0 0 0 0 0 0
## Biobase 0 0 0 0 0 0
## locfit 0 0 0 0 0 1
## BiocParallel 0 0 0 0 0 0
## ggplot2 0 0 0 0 0 0
## geneplotter 0 0 0 0 0 0
## genefilter 0 0 0 0 0 0
## RcppArmadillo 0 0 0 0 0 0
## BiocParallel ggplot2 geneplotter genefilter
## S4Vectors 0 0.00000000 0.00000000 0.00000000
## IRanges 0 0.00000000 0.00000000 0.00000000
## GenomicRanges 0 0.00000000 0.00000000 0.00000000
## SummarizedExperiment 0 0.00000000 0.00000000 0.00000000
## methods 0 0.00000000 0.00000000 0.00000000
## stats4 0 0.00000000 0.00000000 0.00000000
## Rcpp 0 0.00000000 0.00000000 0.00000000
## BiocGenerics 0 0.00000000 0.00000000 0.00000000
## Biobase 0 0.00000000 0.00000000 0.00000000
## locfit 0 0.00000000 0.00000000 0.00000000
## BiocParallel 1 0.00000000 0.00000000 0.00000000
## ggplot2 0 1.00000000 0.04347826 0.04166667
## geneplotter 0 0.04347826 1.00000000 0.88461538
## genefilter 0 0.04166667 0.88461538 1.00000000
## RcppArmadillo 0 0.00000000 0.00000000 0.00000000
## RcppArmadillo
## S4Vectors 0
## IRanges 0
## GenomicRanges 0
## SummarizedExperiment 0
## methods 0
## stats4 0
## Rcpp 0
## BiocGenerics 0
## Biobase 0
## locfit 0
## BiocParallel 0
## ggplot2 0
## geneplotter 0
## genefilter 0
## RcppArmadillo 1
## attr(,"max")
## [1] 0.8846154
## attr(,"max_pair")
## [1] "genefilter" "geneplotter"
But users need to be careful that a small value of \(|S_{AB}|\) may lead to a large Jaccard coeffcient value.
Finally, co-heaviness captures additional dependency packages from and only from two parents, while it does work for more parents. However, the effect of heaviness from multiple parents can always be easily observed from the dependency heatmap.


Icons
ridestyler.ui includes its own custom set of icons that you can use in your interface.

Add a icon
class and the correct icon-[name]
class to an element to display an icon using a pseudo :before
element.
Font Awesome
All of the icons from have been included. Use their website or browse the /src/icons/font-awesome-solid
folder to discover icon names.
icon-arrow-up
icon-arrow-right
icon-arrow-down
icon-arrow-left
icon-angle-double-up
icon-angle-double-right
icon-angle-double-down
icon-angle-double-left
icon-shopping-cart
icon-user-secret
icon-biohazard
icon-sd-card
icon-pizza-slice
Custom icons
Custom icons can easily be added in the future by adding them to the src/icons
folder and rebuilding the fonts.
Icon sizes
Use icon-2x
, icon-3x
and icon-4x
classes to increase icon sizes.
You can set font-size
to have different icon sizes.
icon-2x (2rem)
icon-3x (3rem)
icon-4x (4rem)

SCSS Enhancements
A variable containing the unicode value for each icon is included and can be used in place of the .icon
classes.


Game Panel
Tries
New game
Guess
Play
Moves
Guess
Message
Game Statistics Panel
Wins
Loses
Average Wins Time
Average Move
Average Move Time


#include <shader.h>
Definition at line 959 of file shader.h.
◆ simd_function_unit()
◆ ~simd_function_unit()
| simd_function_unit::~simd_function_unit |
( |
| ) |
|
|
inline |
◆ active_lanes_in_pipeline()
| virtual void simd_function_unit::active_lanes_in_pipeline |
( |
| ) |
|
|
pure virtual |
◆ can_issue()
| virtual bool simd_function_unit::can_issue |
( |
const warp_inst_t & |
inst | ) |
const |
|
inlinevirtual |
◆ clock_multiplier()
| virtual unsigned simd_function_unit::clock_multiplier |
( |
| ) |
const |
|
inlinevirtual |
◆ cycle()
| virtual void simd_function_unit::cycle |
( |
| ) |
|
|
pure virtual |
◆ issue()
| virtual void simd_function_unit::issue |
( |
register_set & |
source_reg | ) |
|
|
inlinevirtual |
◆ print()
| virtual void simd_function_unit::print |
( |
FILE * |
fp | ) |
const |
|
inlinevirtual |
◆ stallable()
| virtual bool simd_function_unit::stallable |
( |
| ) |
const |
|
pure virtual |
◆ m_config
◆ m_dispatch_reg
◆ m_name
| std::string simd_function_unit::m_name |
|
protected |
◆ MAX_ALU_LATENCY
| const unsigned simd_function_unit::MAX_ALU_LATENCY = 512 |
|
staticprotected |
◆ occupied
The documentation for this class was generated from the following files:
- gpgpu-sim_distribution/src/gpgpu-sim/shader.h
- gpgpu-sim_distribution/src/gpgpu-sim/shader.cc


Supreme Court to deliver its verdict on pleas seeking Sabarimala judgment review tomorrow
The apex court will deliver its judgement on as many as 65 petitions which were filed after its verdict sparked violent protests in Kerala
The Supreme Court of India (SC) will, on November 14, deliver its verdict on a batch of petitions seeking re-examination of its earlier decision to allow entry of women of all age group in Kerala's Sabarimala Temple.
The apex court will deliver its judgement on as many as 65 petitions -- including 56 review petitions and four fresh writ petitions and five transfer pleas -- which were filed after its verdict sparked violent protests in Kerala.
A five-judge Constitution bench headed by Chief Justice of India (CJI) Ranjan Gogoi had reserved its decision on February 6, after hearing various parties including those seeking re-consideration of the September 28, 2018 judgement.
Other members of the bench are Justices RF Nariman, AM Khanwilkar, DY Chandrachud and Indu Malhotra.
The apex court, by a majority verdict of 4:1, on September 38, 2018, had lifted the ban that prevented women and girls between the age of 10 and 50 from entering the famous Ayyappa shrine in Kerala and had held that this centuries-old Hindu religious practice was illegal and unconstitutional.
The five-judge Constitution bench had heard the pleas in an open court and reserved its decision after hearing the parties, including Nair Service Society, Thantry of the temple, The Travancore Devaswom Board (TDB) and the Kerala government, in favour and against the review plea.


UIListController
The UIListController
component manages a list of views based on a list of components.
class UIListController
extends
UIRenderableController
<
UIContainer
>
Renderable wrapper that populates an encapsulated container with components, constructed using given view adapter (e.g. preset constructor for UIListCellAdapter
components); each instance of the view adapter corresponds to exactly one value from a list.
Constructor
(content?:
UIContainer
): UIListController
.onFocusIn() protected
(e:
ComponentEvent
<
Component
>): boolean
Handle FocusIn events, saving the index of the focused item or restoring focus on the item that was focused last.
.onArrowUpKeyPress() protected
(): boolean
Handle ArrowUpKeyPress events, focusing the previous list item.
.onArrowDownKeyPress() protected
(): boolean
Handle ArrowDownKeyPress events, focusing the next list item.
.enableArrowKeyFocus
boolean
Set to true to enable selection (focus movement) using up/down arrow keys.
.items
List of objects, each object is used to construct one content component.
.firstIndex
number
Index of first item to be shown in the list (for e.g. pagination, or sliding window positioning), defaults to 0.
.maxItems
number
Maximum number of items to be shown in the list (for e.g. pagination, or sliding window positioning), defaults to undefined
to show all items.
.lastFocusedIndex
number
Last focused index, if any.
.getIndexOfComponent()
(component?:
Component
): number
Returns the list index of given component, or of the component that it is contained in; or returns -1 if given component is not found in the list.
.restoreFocus()
(): void
Request input focus for the last focused list component, or the first item, if possible.
.focusPreviousItem()
(): boolean
Request input focus for the item before the currently focused item; returns true if such an item exists, false if the currently focused item is already the first item or there are no items in the list.
.focusNextItem()
(): boolean
Request input focus for the item after the currently focused item; returns true if such an item exists, false if the currently focused item is already the last item or if there are no items in the list.
.renderContext
Inherited from UIRenderableController.renderContext
.
.content
TContent
Inherited from UIRenderableController.content
.
.delegateEvent() protected
(e:
ManagedEvent
, propertyName: string): true
Inherited from UIRenderableController.delegateEvent
.
.render()
(callback?: RenderCallback<Output<
UIRenderable
, any>>): void
Inherited from UIRenderableController.render
.
.isPresetComponent() protected
(): boolean
Inherited from Component.isPresetComponent
.
.getParentComponent()
<TParent extends Component = Component>(ParentClass?:
ComponentConstructor
<TParent>): TParent
Inherited from Component.getParentComponent
.
.getBoundParentComponent()
<TParent extends Component>(ParentClass?:
ComponentConstructor
<TParent>): TParent
Inherited from Component.getBoundParentComponent
.
.emitAction()
(name: string, inner?:
ManagedEvent
, context?:
ManagedObject
): void
Inherited from Component.emitAction
.
.propagateComponentEvent() deprecated
(name: string, inner?:
ManagedEvent
): void
Inherited from Component.propagateComponentEvent
.
.managedId
number
Inherited from ManagedObject.managedId
.
.managedState
Inherited from ManagedObject.managedState
.
.getReferenceCount() protected
(): number
Inherited from ManagedObject.getReferenceCount
.
.getManagedReferrers() protected
():
ManagedObject
[]
Inherited from ManagedObject.getManagedReferrers
.
.getManagedParent() protected
<TParent extends ManagedObject = ManagedObject>(ParentClass?:
ManagedObjectConstructor
<TParent>): TParent
Inherited from ManagedObject.getManagedParent
.
.emit()
<TEvent extends ManagedEvent = ManagedEvent, TConstructorArgs extends any[] = any[]>(e: string | TEvent | (new (...args: TConstructorArgs) => TEvent), ...constructorArgs: TConstructorArgs): this
Inherited from ManagedObject.emit
.
.emitChange()
(name?: string): void
Inherited from ManagedObject.emitChange
.
.propagateChildEvents() protected deprecated
(...types: ((new (...args: any[]) =>
ManagedEvent
) | ((e:
ManagedEvent
) => any))[]): this
Inherited from ManagedObject.propagateChildEvents
.
.activateManagedAsync() protected
(): Promise<any>
Inherited from ManagedObject.activateManagedAsync
.
.deactivateManagedAsync() protected
(): Promise<void>
Inherited from ManagedObject.deactivateManagedAsync
.
.destroyManagedAsync() protected
(): Promise<void>
Inherited from ManagedObject.destroyManagedAsync
.
.onManagedStateActivatingAsync() protected
(): Promise<void>
Inherited from ManagedObject.onManagedStateActivatingAsync
.
.onManagedStateActiveAsync() protected
(): Promise<void>
Inherited from ManagedObject.onManagedStateActiveAsync
.
.onManagedStateDeactivatingAsync() protected
(): Promise<void>
Inherited from ManagedObject.onManagedStateDeactivatingAsync
.
.onManagedStateInactiveAsync() protected
(): Promise<void>
Inherited from ManagedObject.onManagedStateInactiveAsync
.
.onManagedStateDestroyingAsync() protected
(): Promise<void>
Inherited from ManagedObject.onManagedStateDestroyingAsync
.
UIListController.Presets
UIListController presets type, for use with Component.with
.
.items
Iterable<
ManagedObject
>
List of items: initial values, or a list binding.
.enableArrowKeyFocus
boolean
Set to true to enable selection (focus movement) using up/down arrow keys.
.firstIndex
number
Index of first item to be shown in the list (for e.g. pagination, or sliding window positioning), defaults to 0.
.maxItems
number
Maximum number of items to be shown in the list (for e.g. pagination, or sliding window positioning), defaults to undefined
to show all items.
.onListItemsChange
ComponentEventHandler
<UIListController,
ComponentEvent
<
Component
>>
Event handler for any change in displayed list items, and list initialization.


{% extends "page.html" %} {% if announcement_login %} {% set announcement = announcement_login %} {% endif %} {% block stylesheet %} {{ super() }} {% endblock %} {% block login_widget %} {% endblock %} {% block main %} {% block login %}
Notebooks is an environment based on Jupyter and the EGI cloud service that offers a browser-based, scalable tool for interactive data analysis. The Notebooks environment provides users with notebooks where they can combine text, mathematics, computations and rich media output.