text:
[source]

### Convolution1D

keras.layers.convolutional.Convolution1D(nb_filter, filter_length, init='glorot_uniform', activation=None, weights=None, border_mode='valid', subsample_length=1, W_regularizer=None, b_regularizer=None, activity_regularizer=None, W_constraint=None, b_constraint=None, bias=True, input_dim=None, input_length=None)

Convolution operator for filtering neighborhoods of one-dimensional inputs. When using this layer as the first layer in a model, either provide the keyword argument input_dim (int, e.g. 128 for sequences of 128-dimensional vectors), or input_shape (tuple of integers, e.g. (10, 128) for sequences of 10 vectors of 128-dimensional vectors).

Example

# apply a convolution 1d of length 3 to a sequence with 10 timesteps,
# with 64 output filters
model = Sequential()
# now model.output_shape == (None, 10, 64)

# add a new conv1d on top
# now model.output_shape == (None, 10, 32)

Arguments

• nb_filter: Number of convolution kernels to use (dimensionality of the output).
• filter_length: The extension (spatial or temporal) of each filter.
• init: name of initialization function for the weights of the layer (see initializations), or alternatively, Theano function to use for weights initialization. This parameter is only relevant if you don't pass a weights argument.
• activation: name of activation function to use (see activations), or alternatively, elementwise Theano function. If you don't specify anything, no activation is applied (ie. "linear" activation: a(x) = x).
• weights: list of numpy arrays to set as initial weights.
• border_mode: 'valid', 'same' or 'full'. ('full' requires the Theano backend.)
• subsample_length: factor by which to subsample output.
• W_regularizer: instance of WeightRegularizer (eg. L1 or L2 regularization), applied to the main weights matrix.
• b_regularizer: instance of WeightRegularizer, applied to the bias.
• activity_regularizer: instance of ActivityRegularizer, applied to the network output.
• W_constraint: instance of the constraints module (eg. maxnorm, nonneg), applied to the main weights matrix.
• b_constraint: instance of the constraints module, applied to the bias.
• bias: whether to include a bias (i.e. make the layer affine rather than linear).
• input_dim: Number of channels/dimensions in the input. Either this argument or the keyword argument input_shapemust be provided when using this layer as the first layer in a model.
• input_length: Length of input sequences, when it is constant. This argument is required if you are going to connect Flatten then Dense layers upstream (without it, the shape of the dense outputs cannot be computed).

Input shape

3D tensor with shape: (samples, steps, input_dim).

Output shape

3D tensor with shape: (samples, new_steps, nb_filter). steps value might have changed due to padding.

[source]

### AtrousConvolution1D

keras.layers.convolutional.AtrousConvolution1D(nb_filter, filter_length, init='glorot_uniform', activation=None, weights=None, border_mode='valid', subsample_length=1, atrous_rate=1, W_regularizer=None, b_regularizer=None, activity_regularizer=None, W_constraint=None, b_constraint=None, bias=True)

Atrous Convolution operator for filtering neighborhoods of one-dimensional inputs. A.k.a dilated convolution or convolution with holes. When using this layer as the first layer in a model, either provide the keyword argument input_dim (int, e.g. 128 for sequences of 128-dimensional vectors), or input_shape (tuples of integers, e.g. (10, 128) for sequences of 10 vectors of 128-dimensional vectors).

Example

# apply an atrous convolution 1d with atrous rate 2 of length 3 to a sequence with 10 timesteps,
# with 64 output filters
model = Sequential()
model.add(AtrousConvolution1D(64, 3, atrous_rate=2, border_mode='same', input_shape=(10, 32)))
# now model.output_shape == (None, 10, 64)

# add a new atrous conv1d on top
# now model.output_shape == (None, 10, 32)

Arguments

• nb_filter: Number of convolution kernels to use (dimensionality of the output).
• filter_length: The extension (spatial or temporal) of each filter.
• init: name of initialization function for the weights of the layer (see initializations), or alternatively, Theano function to use for weights initialization. This parameter is only relevant if you don't pass a weights argument.
• activation: name of activation function to use (see activations), or alternatively, elementwise Theano function. If you don't specify anything, no activation is applied (ie. "linear" activation: a(x) = x).
• weights: list of numpy arrays to set as initial weights.
• border_mode: 'valid', 'same' or 'full'. ('full' requires the Theano backend.)
• subsample_length: factor by which to subsample output.
• atrous_rate: Factor for kernel dilation. Also called filter_dilation elsewhere.
• W_regularizer: instance of WeightRegularizer (eg. L1 or L2 regularization), applied to the main weights matrix.
• b_regularizer: instance of WeightRegularizer, applied to the bias.
• activity_regularizer: instance of ActivityRegularizer, applied to the network output.
• W_constraint: instance of the constraints module (eg. maxnorm, nonneg), applied to the main weights matrix.
• b_constraint: instance of the constraints module, applied to the bias.
• bias: whether to include a bias (i.e. make the layer affine rather than linear).
• input_dim: Number of channels/dimensions in the input. Either this argument or the keyword argument input_shapemust be provided when using this layer as the first layer in a model.
• input_length: Length of input sequences, when it is constant. This argument is required if you are going to connect Flatten then Dense layers upstream (without it, the shape of the dense outputs cannot be computed).

Input shape

3D tensor with shape: (samples, steps, input_dim).

Output shape

3D tensor with shape: (samples, new_steps, nb_filter). steps value might have changed due to padding.

[source]

### Convolution2D

keras.layers.convolutional.Convolution2D(nb_filter, nb_row, nb_col, init='glorot_uniform', activation=None, weights=None, border_mode='valid', subsample=(1, 1), dim_ordering='default', W_regularizer=None, b_regularizer=None, activity_regularizer=None, W_constraint=None, b_constraint=None, bias=True)

Convolution operator for filtering windows of two-dimensional inputs. When using this layer as the first layer in a model, provide the keyword argument input_shape (tuple of integers, does not include the sample axis), e.g. input_shape=(3, 128, 128) for 128x128 RGB pictures.

Examples

# apply a 3x3 convolution with 64 output filters on a 256x256 image:
model = Sequential()
model.add(Convolution2D(64, 3, 3, border_mode='same', input_shape=(3, 256, 256)))
# now model.output_shape == (None, 64, 256, 256)

# add a 3x3 convolution on top, with 32 output filters:
# now model.output_shape == (None, 32, 256, 256)

Arguments

• nb_filter: Number of convolution filters to use.
• nb_row: Number of rows in the convolution kernel.
• nb_col: Number of columns in the convolution kernel.
• init: name of initialization function for the weights of the layer (see initializations), or alternatively, Theano function to use for weights initialization. This parameter is only relevant if you don't pass a weights argument.
• activation: name of activation function to use (see activations), or alternatively, elementwise Theano function. If you don't specify anything, no activation is applied (ie. "linear" activation: a(x) = x).
• weights: list of numpy arrays to set as initial weights.
• border_mode: 'valid', 'same' or 'full'. ('full' requires the Theano backend.)
• subsample: tuple of length 2. Factor by which to subsample output. Also called strides elsewhere.
• W_regularizer: instance of WeightRegularizer (eg. L1 or L2 regularization), applied to the main weights matrix.
• b_regularizer: instance of WeightRegularizer, applied to the bias.
• activity_regularizer: instance of ActivityRegularizer, applied to the network output.
• W_constraint: instance of the constraints module (eg. maxnorm, nonneg), applied to the main weights matrix.
• b_constraint: instance of the constraints module, applied to the bias.
• dim_ordering: 'th' or 'tf'. In 'th' mode, the channels dimension (the depth) is at index 1, in 'tf' mode is it at index 3. It defaults to the image_dim_ordering value found in your Keras config file at ~/.keras/keras.json. If you never set it, then it will be "tf".
• bias: whether to include a bias (i.e. make the layer affine rather than linear).

Input shape

4D tensor with shape: (samples, channels, rows, cols) if dim_ordering='th' or 4D tensor with shape: (samples, rows, cols, channels) if dim_ordering='tf'.

Output shape

4D tensor with shape: (samples, nb_filter, new_rows, new_cols) if dim_ordering='th' or 4D tensor with shape: (samples, new_rows, new_cols, nb_filter) if dim_ordering='tf'. rows and cols values might have changed due to padding.

[source]

### AtrousConvolution2D

keras.layers.convolutional.AtrousConvolution2D(nb_filter, nb_row, nb_col, init='glorot_uniform', activation=None, weights=None, border_mode='valid', subsample=(1, 1), atrous_rate=(1, 1), dim_ordering='default', W_regularizer=None, b_regularizer=None, activity_regularizer=None, W_constraint=None, b_constraint=None, bias=True)

Atrous Convolution operator for filtering windows of two-dimensional inputs. A.k.a dilated convolution or convolution with holes. When using this layer as the first layer in a model, provide the keyword argument input_shape (tuple of integers, does not include the sample axis), e.g. input_shape=(3, 128, 128) for 128x128 RGB pictures.

Examples

# apply a 3x3 convolution with atrous rate 2x2 and 64 output filters on a 256x256 image:
model = Sequential()
model.add(AtrousConvolution2D(64, 3, 3, atrous_rate=(2,2), border_mode='valid', input_shape=(3, 256, 256)))
# now the actual kernel size is dilated from 3x3 to 5x5 (3+(3-1)*(2-1)=5)
# thus model.output_shape == (None, 64, 252, 252)

Arguments

• nb_filter: Number of convolution filters to use.
• nb_row: Number of rows in the convolution kernel.
• nb_col: Number of columns in the convolution kernel.
• init: name of initialization function for the weights of the layer (see initializations), or alternatively, Theano function to use for weights initialization. This parameter is only relevant if you don't pass a weights argument.
• activation: name of activation function to use (see activations), or alternatively, elementwise Theano function. If you don't specify anything, no activation is applied (ie. "linear" activation: a(x) = x).
• weights: list of numpy arrays to set as initial weights.
• border_mode: 'valid', 'same' or 'full'. ('full' requires the Theano backend.)
• subsample: tuple of length 2. Factor by which to subsample output. Also called strides elsewhere.
• atrous_rate: tuple of length 2. Factor for kernel dilation. Also called filter_dilation elsewhere.
• W_regularizer: instance of WeightRegularizer (eg. L1 or L2 regularization), applied to the main weights matrix.
• b_regularizer: instance of WeightRegularizer, applied to the bias.
• activity_regularizer: instance of ActivityRegularizer, applied to the network output.
• W_constraint: instance of the constraints module (eg. maxnorm, nonneg), applied to the main weights matrix.
• b_constraint: instance of the constraints module, applied to the bias.
• dim_ordering: 'th' or 'tf'. In 'th' mode, the channels dimension (the depth) is at index 1, in 'tf' mode is it at index 3. It defaults to the image_dim_ordering value found in your Keras config file at ~/.keras/keras.json. If you never set it, then it will be "tf".
• bias: whether to include a bias (i.e. make the layer affine rather than linear).

Input shape

4D tensor with shape: (samples, channels, rows, cols) if dim_ordering='th' or 4D tensor with shape: (samples, rows, cols, channels) if dim_ordering='tf'.

Output shape

4D tensor with shape: (samples, nb_filter, new_rows, new_cols) if dim_ordering='th' or 4D tensor with shape: (samples, new_rows, new_cols, nb_filter) if dim_ordering='tf'. rows and cols values might have changed due to padding.

References

[source]

### SeparableConvolution2D

keras.layers.convolutional.SeparableConvolution2D(nb_filter, nb_row, nb_col, init='glorot_uniform', activation=None, weights=None, border_mode='valid', subsample=(1, 1), depth_multiplier=1, dim_ordering='default', depthwise_regularizer=None, pointwise_regularizer=None, b_regularizer=None, activity_regularizer=None, depthwise_constraint=None, pointwise_constraint=None, b_constraint=None, bias=True)

Separable convolution operator for 2D inputs.

Separable convolutions consist in first performing a depthwise spatial convolution (which acts on each input channel separately) followed by a pointwise convolution which mixes together the resulting output channels. The depth_multiplier argument controls how many output channels are generated per input channel in the depthwise step.

Intuitively, separable convolutions can be understood as a way to factorize a convolution kernel into two smaller kernels, or as an extreme version of an Inception block.

When using this layer as the first layer in a model, provide the keyword argument input_shape (tuple of integers, does not include the sample axis), e.g. input_shape=(3, 128, 128) for 128x128 RGB pictures.

Theano warning

This layer is only available with the TensorFlow backend for the time being.

Arguments

• nb_filter: Number of convolution filters to use.
• nb_row: Number of rows in the convolution kernel.
• nb_col: Number of columns in the convolution kernel.
• init: name of initialization function for the weights of the layer (see initializations), or alternatively, Theano function to use for weights initialization. This parameter is only relevant if you don't pass a weights argument.
• activation: name of activation function to use (see activations), or alternatively, elementwise Theano function. If you don't specify anything, no activation is applied (ie. "linear" activation: a(x) = x).
• weights: list of numpy arrays to set as initial weights.
• border_mode: 'valid' or 'same'.
• subsample: tuple of length 2. Factor by which to subsample output. Also called strides elsewhere.
• depth_multiplier: how many output channel to use per input channel for the depthwise convolution step.
• depthwise_regularizer: instance of WeightRegularizer (eg. L1 or L2 regularization), applied to the depthwise weights matrix.
• pointwise_regularizer: instance of WeightRegularizer (eg. L1 or L2 regularization), applied to the pointwise weights matrix.
• b_regularizer: instance of WeightRegularizer, applied to the bias.
• activity_regularizer: instance of ActivityRegularizer, applied to the network output.
• depthwise_constraint: instance of the constraints module (eg. maxnorm, nonneg), applied to the depthwise weights matrix.
• pointwise_constraint: instance of the constraints module (eg. maxnorm, nonneg), applied to the pointwise weights matrix.
• b_constraint: instance of the constraints module, applied to the bias.
• dim_ordering: 'th' or 'tf'. In 'th' mode, the channels dimension (the depth) is at index 1, in 'tf' mode is it at index 3. It defaults to the image_dim_ordering value found in your Keras config file at ~/.keras/keras.json. If you never set it, then it will be "tf".
• bias: whether to include a bias (i.e. make the layer affine rather than linear).

Input shape

4D tensor with shape: (samples, channels, rows, cols) if dim_ordering='th' or 4D tensor with shape: (samples, rows, cols, channels) if dim_ordering='tf'.

Output shape

4D tensor with shape: (samples, nb_filter, new_rows, new_cols) if dim_ordering='th' or 4D tensor with shape: (samples, new_rows, new_cols, nb_filter) if dim_ordering='tf'. rows and cols values might have changed due to padding.

[source]

### Deconvolution2D

keras.layers.convolutional.Deconvolution2D(nb_filter, nb_row, nb_col, output_shape, init='glorot_uniform', activation=None, weights=None, border_mode='valid', subsample=(1, 1), dim_ordering='default', W_regularizer=None, b_regularizer=None, activity_regularizer=None, W_constraint=None, b_constraint=None, bias=True)

Transposed convolution operator for filtering windows of two-dimensional inputs. The need for transposed convolutions generally arises from the desire to use a transformation going in the opposite direction of a normal convolution, i.e., from something that has the shape of the output of some convolution to something that has the shape of its input while maintaining a connectivity pattern that is compatible with said convolution. [1]

When using this layer as the first layer in a model, provide the keyword argument input_shape (tuple of integers, does not include the sample axis), e.g. input_shape=(3, 128, 128) for 128x128 RGB pictures.

To pass the correct output_shape to this layer, one could use a test model to predict and observe the actual output shape.

Examples

# apply a 3x3 transposed convolution with stride 1x1 and 3 output filters on a 12x12 image:
model = Sequential()
model.add(Deconvolution2D(3, 3, 3, output_shape=(None, 3, 14, 14), border_mode='valid', input_shape=(3, 12, 12)))
# Note that you will have to change the output_shape depending on the backend used.

# we can predict with the model and print the shape of the array.
dummy_input = np.ones((32, 3, 12, 12))
# For TensorFlow dummy_input = np.ones((32, 12, 12, 3))
preds = model.predict(dummy_input)
print(preds.shape)
# Theano GPU: (None, 3, 13, 13)
# Theano CPU: (None, 3, 14, 14)
# TensorFlow: (None, 14, 14, 3)

# apply a 3x3 transposed convolution with stride 2x2 and 3 output filters on a 12x12 image:
model = Sequential()
model.add(Deconvolution2D(3, 3, 3, output_shape=(None, 3, 25, 25), subsample=(2, 2), border_mode='valid', input_shape=(3, 12, 12)))
model.summary()

# we can predict with the model and print the shape of the array.
dummy_input = np.ones((32, 3, 12, 12))
# For TensorFlow dummy_input = np.ones((32, 12, 12, 3))
preds = model.predict(dummy_input)
print(preds.shape)
# Theano GPU: (None, 3, 25, 25)
# Theano CPU: (None, 3, 25, 25)
# TensorFlow: (None, 25, 25, 3)

Arguments

• nb_filter: Number of transposed convolution filters to use.
• nb_row: Number of rows in the transposed convolution kernel.
• nb_col: Number of columns in the transposed convolution kernel.
• output_shape: Output shape of the transposed convolution operation. tuple of integers (nb_samples, nb_filter, nb_output_rows, nb_output_cols) Formula for calculation of the output shape [1], [2]: o = s (i - 1) + a + k - 2p, \quad a \in {0, \ldots, s - 1}
• where: i - input size (rows or cols), k - kernel size (nb_filter), s - stride (subsample for rows or cols respectively), p - padding size, a - user-specified quantity used to distinguish between the s different possible output sizes. Because a is not specified explicitly and Theano and Tensorflow use different values, it is better to use a dummy input and observe the actual output shape of a layer as specified in the examples.
• init: name of initialization function for the weights of the layer (see initializations), or alternatively, Theano function to use for weights initialization. This parameter is only relevant if you don't pass a weights argument.
• activation: name of activation function to use (see activations), or alternatively, elementwise Theano/TensorFlow function. If you don't specify anything, no activation is applied (ie. "linear" activation: a(x) = x).
• weights: list of numpy arrays to set as initial weights.
• border_mode: 'valid', 'same' or 'full'. ('full' requires the Theano backend.)
• subsample: tuple of length 2. Factor by which to oversample output. Also called strides elsewhere.
• W_regularizer: instance of WeightRegularizer (eg. L1 or L2 regularization), applied to the main weights matrix.
• b_regularizer: instance of WeightRegularizer, applied to the bias.
• activity_regularizer: instance of ActivityRegularizer, applied to the network output.
• W_constraint: instance of the constraints module (eg. maxnorm, nonneg), applied to the main weights matrix.
• b_constraint: instance of the constraints module, applied to the bias.
• dim_ordering: 'th' or 'tf'. In 'th' mode, the channels dimension (the depth) is at index 1, in 'tf' mode is it at index 3. It defaults to the image_dim_ordering value found in your Keras config file at ~/.keras/keras.json. If you never set it, then it will be "tf".
• bias: whether to include a bias (i.e. make the layer affine rather than linear).

Input shape

4D tensor with shape: (samples, channels, rows, cols) if dim_ordering='th' or 4D tensor with shape: (samples, rows, cols, channels) if dim_ordering='tf'.

Output shape

4D tensor with shape: (samples, nb_filter, new_rows, new_cols) if dim_ordering='th' or 4D tensor with shape: (samples, new_rows, new_cols, nb_filter) if dim_ordering='tf'. rows and cols values might have changed due to padding.

References

[source]

### Convolution3D

keras.layers.convolutional.Convolution3D(nb_filter, kernel_dim1, kernel_dim2, kernel_dim3, init='glorot_uniform', activation=None, weights=None, border_mode='valid', subsample=(1, 1, 1), dim_ordering='default', W_regularizer=None, b_regularizer=None, activity_regularizer=None, W_constraint=None, b_constraint=None, bias=True)

Convolution operator for filtering windows of three-dimensional inputs. When using this layer as the first layer in a model, provide the keyword argument input_shape (tuple of integers, does not include the sample axis), e.g. input_shape=(3, 10, 128, 128) for 10 frames of 128x128 RGB pictures.

Arguments

• nb_filter: Number of convolution filters to use.
• kernel_dim1: Length of the first dimension in the convolution kernel.
• kernel_dim2: Length of the second dimension in the convolution kernel.
• kernel_dim3: Length of the third dimension in the convolution kernel.
• init: name of initialization function for the weights of the layer (see initializations), or alternatively, Theano function to use for weights initialization. This parameter is only relevant if you don't pass a weights argument.
• activation: name of activation function to use (see activations), or alternatively, elementwise Theano function. If you don't specify anything, no activation is applied (ie. "linear" activation: a(x) = x).
• weights: list of Numpy arrays to set as initial weights.
• border_mode: 'valid', 'same' or 'full'. ('full' requires the Theano backend.)
• subsample: tuple of length 3. Factor by which to subsample output. Also called strides elsewhere.
• Note: 'subsample' is implemented by slicing the output of conv3d with strides=(1,1,1).
• W_regularizer: instance of WeightRegularizer (eg. L1 or L2 regularization), applied to the main weights matrix.
• b_regularizer: instance of WeightRegularizer, applied to the bias.
• activity_regularizer: instance of ActivityRegularizer, applied to the network output.
• W_constraint: instance of the constraints module (eg. maxnorm, nonneg), applied to the main weights matrix.
• b_constraint: instance of the constraints module, applied to the bias.
• dim_ordering: 'th' or 'tf'. In 'th' mode, the channels dimension (the depth) is at index 1, in 'tf' mode is it at index 4. It defaults to the image_dim_ordering value found in your Keras config file at ~/.keras/keras.json. If you never set it, then it will be "tf".
• bias: whether to include a bias (i.e. make the layer affine rather than linear).

Input shape

5D tensor with shape: (samples, channels, conv_dim1, conv_dim2, conv_dim3) if dim_ordering='th' or 5D tensor with shape: (samples, conv_dim1, conv_dim2, conv_dim3, channels) if dim_ordering='tf'.

Output shape

5D tensor with shape: (samples, nb_filter, new_conv_dim1, new_conv_dim2, new_conv_dim3) if dim_ordering='th' or 5D tensor with shape: (samples, new_conv_dim1, new_conv_dim2, new_conv_dim3, nb_filter) if dim_ordering='tf'. new_conv_dim1, new_conv_dim2 and new_conv_dim3 values might have changed due to padding.

[source]

### Cropping1D

keras.layers.convolutional.Cropping1D(cropping=(1, 1))

Cropping layer for 1D input (e.g. temporal sequence). It crops along the time dimension (axis 1).

Arguments

• cropping: tuple of int (length 2) How many units should be trimmed off at the beginning and end of the cropping dimension (axis 1).

Input shape

3D tensor with shape (samples, axis_to_crop, features)

Output shape

3D tensor with shape (samples, cropped_axis, features)

[source]

### Cropping2D

keras.layers.convolutional.Cropping2D(cropping=((0, 0), (0, 0)), dim_ordering='default')

Cropping layer for 2D input (e.g. picture). It crops along spatial dimensions, i.e. width and height.

Arguments

• cropping: tuple of tuple of int (length 2) How many units should be trimmed off at the beginning and end of the 2 cropping dimensions (width, height).
• dim_ordering: 'th' or 'tf'. In 'th' mode, the channels dimension (the depth) is at index 1, in 'tf' mode is it at index 3. It defaults to the image_dim_ordering value found in your Keras config file at ~/.keras/keras.json. If you never set it, then it will be "tf".

Input shape

4D tensor with shape: (samples, depth, first_axis_to_crop, second_axis_to_crop)

Output shape

4D tensor with shape: (samples, depth, first_cropped_axis, second_cropped_axis)

Examples

# Crop the input 2D images or feature maps
model = Sequential()
model.add(Cropping2D(cropping=((2, 2), (4, 4)), input_shape=(3, 28, 28)))
# now model.output_shape == (None, 3, 24, 20)
# now model.output_shape == (None, 64, 20, 16)

[source]

### Cropping3D

keras.layers.convolutional.Cropping3D(cropping=((1, 1), (1, 1), (1, 1)), dim_ordering='default')

Cropping layer for 3D data (e.g. spatial or spatio-temporal).

Arguments

• cropping: tuple of tuple of int (length 3) How many units should be trimmed off at the beginning and end of the 3 cropping dimensions (kernel_dim1, kernel_dim2, kernerl_dim3).
• dim_ordering: 'th' or 'tf'. In 'th' mode, the channels dimension (the depth) is at index 1, in 'tf' mode is it at index 4. It defaults to the image_dim_ordering value found in your Keras config file at ~/.keras/keras.json. If you never set it, then it will be "tf".

Input shape

5D tensor with shape: (samples, depth, first_axis_to_crop, second_axis_to_crop, third_axis_to_crop)

Output shape

5D tensor with shape: (samples, depth, first_cropped_axis, second_cropped_axis, third_cropped_axis)

[source]

### UpSampling1D

keras.layers.convolutional.UpSampling1D(length=2)

Repeat each temporal step length times along the time axis.

Arguments

• length: integer. Upsampling factor.

Input shape

3D tensor with shape: (samples, steps, features).

Output shape

3D tensor with shape: (samples, upsampled_steps, features).

[source]

### UpSampling2D

keras.layers.convolutional.UpSampling2D(size=(2, 2), dim_ordering='default')

Repeat the rows and columns of the data by size[0] and size[1] respectively.

Arguments

• size: tuple of 2 integers. The upsampling factors for rows and columns.
• dim_ordering: 'th' or 'tf'. In 'th' mode, the channels dimension (the depth) is at index 1, in 'tf' mode is it at index 3. It defaults to the image_dim_ordering value found in your Keras config file at ~/.keras/keras.json. If you never set it, then it will be "tf".

Input shape

4D tensor with shape: (samples, channels, rows, cols) if dim_ordering='th' or 4D tensor with shape: (samples, rows, cols, channels) if dim_ordering='tf'.

Output shape

4D tensor with shape: (samples, channels, upsampled_rows, upsampled_cols) if dim_ordering='th' or 4D tensor with shape: (samples, upsampled_rows, upsampled_cols, channels) if dim_ordering='tf'.

[source]

### UpSampling3D

keras.layers.convolutional.UpSampling3D(size=(2, 2, 2), dim_ordering='default')

Repeat the first, second and third dimension of the data by size[0], size[1] and size[2] respectively.

Arguments

• size: tuple of 3 integers. The upsampling factors for dim1, dim2 and dim3.
• dim_ordering: 'th' or 'tf'. In 'th' mode, the channels dimension (the depth) is at index 1, in 'tf' mode is it at index 4. It defaults to the image_dim_ordering value found in your Keras config file at ~/.keras/keras.json. If you never set it, then it will be "tf".

Input shape

5D tensor with shape: (samples, channels, dim1, dim2, dim3) if dim_ordering='th' or 5D tensor with shape: (samples, dim1, dim2, dim3, channels) if dim_ordering='tf'.

Output shape

5D tensor with shape: (samples, channels, upsampled_dim1, upsampled_dim2, upsampled_dim3) if dim_ordering='th' or 5D tensor with shape: (samples, upsampled_dim1, upsampled_dim2, upsampled_dim3, channels) if dim_ordering='tf'.

[source]

keras.layers.convolutional.ZeroPadding1D(padding=1)

Zero-padding layer for 1D input (e.g. temporal sequence).

Arguments

• padding: int, or tuple of int (length 2), or dictionary.
• If int: How many zeros to add at the beginning and end of the padding dimension (axis 1).
• If tuple of int (length 2) How many zeros to add at the beginning and at the end of the padding dimension, in order '(left_pad, right_pad)'.
• If dictionary: should contain the keys {'left_pad', 'right_pad'}. If any key is missing, default value of 0 will be used for the missing key.

Input shape

3D tensor with shape (samples, axis_to_pad, features)

Output shape

3D tensor with shape (samples, padded_axis, features)

[source]

keras.layers.convolutional.ZeroPadding2D(padding=(1, 1), dim_ordering='default')

Zero-padding layer for 2D input (e.g. picture).

Arguments

• padding: tuple of int (length 2), or tuple of int (length 4), or dictionary.
• If tuple of int (length 2): How many zeros to add at the beginning and end of the 2 padding dimensions (rows and cols).
• If tuple of int (length 4): How many zeros to add at the beginning and at the end of the 2 padding dimensions (rows and cols), in the order '(top_pad, bottom_pad, left_pad, right_pad)'.
• If dictionary: should contain the keys {'top_pad', 'bottom_pad', 'left_pad', 'right_pad'}. If any key is missing, default value of 0 will be used for the missing key.
• dim_ordering: 'th' or 'tf'. In 'th' mode, the channels dimension (the depth) is at index 1, in 'tf' mode is it at index 3. It defaults to the image_dim_ordering value found in your Keras config file at ~/.keras/keras.json. If you never set it, then it will be "tf".

Input shape

4D tensor with shape: (samples, channels, rows, cols) if dim_ordering='th' or 4D tensor with shape: (samples, rows, cols, channels) if dim_ordering='tf'.

Output shape

4D tensor with shape: (samples, channels, padded_rows, padded_cols) if dim_ordering='th' or 4D tensor with shape: (samples, padded_rows, padded_cols, channels) if dim_ordering='tf'.

[source]

keras.layers.convolutional.ZeroPadding3D(padding=(1, 1, 1), dim_ordering='default')

Zero-padding layer for 3D data (spatial or spatio-temporal).

Arguments

• padding: tuple of int (length 3) How many zeros to add at the beginning and end of the 3 padding dimensions (axis 3, 4 and 5). Currently only symmetric padding is supported.
• dim_ordering: 'th' or 'tf'. In 'th' mode, the channels dimension (the depth) is at index 1, in 'tf' mode is it at index 4. It defaults to the image_dim_ordering value found in your Keras config file at ~/.keras/keras.json. If you never set it, then it will be "tf".

Input shape


text:
## Loop-Shaping Control Design of Aircraft Model

To see how the loopsyn command works in practice to address robustness and performance tradeoffs, consider again the NASA HiMAT aircraft model taken from the paper of Safonov, Laub, and Hartmann [8]. The longitudinal dynamics of the HiMAT aircraft trimmed at 25000 ft and 0.9 Mach are unstable and have two right-half-plane phugoid modes. The linear model has state-space realization G(s) = C(Is – A)–1B with six states, with the first four states representing angle of attack (α) and attitude angle (θ) and their rates of change, and the last two representing elevon and canard control actuator dynamics — see Aircraft Configuration and Vertical Plane Geometry.

ag = [ -2.2567e-02 -3.6617e+01 -1.8897e+01 -3.2090e+01 3.2509e+00 -7.6257e-01; 9.2572e-05 -1.8997e+00 9.8312e-01 -7.2562e-04 -1.7080e-01 -4.9652e-03; 1.2338e-02 1.1720e+01 -2.6316e+00 8.7582e-04 -3.1604e+01 2.2396e+01; 0 0 1.0000e+00 0 0 0; 0 0 0 0 -3.0000e+01 0; 0 0 0 0 0 -3.0000e+01]; bg = [0 0; 0 0; 0 0; 0 0; 30 0; 0 30]; cg = [0 1 0 0 0 0; 0 0 0 1 0 0]; dg = [0 0; 0 0]; G = ss(ag,bg,cg,dg);

The control variables are elevon and canard actuators (δe and δc). The output variables are angle of attack (α) and attitude angle (θ).

Aircraft Configuration and Vertical Plane Geometry

This model is good at frequencies below 100 rad/s with less than 30% variation between the true aircraft and the model in this frequency range. However as noted in [8], it does not reliably capture very high-frequency behaviors, because it was derived by treating the aircraft as a rigid body and neglecting lightly damped fuselage bending modes that occur at somewhere between 100 and 300 rad/s. These unmodeled bending modes might cause as much as 20 dB deviation (i.e., 1000%) between the frequency response of the model and the actual aircraft for frequency ω > 100 rad/s. Other effects like control actuator time delays and fuel sloshing also contribute to model inaccuracy at even higher frequencies, but the dominant unmodeled effects are the fuselage bending modes. You can think of these unmodeled bending modes as multiplicative uncertainty of size 20 dB, and design your controller using loopsyn, by making sure that the loop has gain less than –20 dB at, and beyond, the frequency ω > 100 rad/s.

### Design Specifications

The singular value design specifications are

• Robustness Spec.: –20 dB/decade roll-off slope and –20 dB loop gain at 100 rad/s

• Performance Spec.: Minimize the sensitivity function as much as possible.

Both specs can be accommodated by taking as the desired loop shape

Gd(s)=8/s

### MATLAB Commands for a LOOPSYN Design

s = zpk('s'); % Laplace variable s Gd = 8/s; % desired loop shape % Compute the optimal loop shaping controller K [K,CL,GAM] = loopsyn(G,Gd); % Compute the loop L, sensitivity S and complementary sensitivity T: L = G*K; I = eye(size(L)); S = feedback(I,L); % S=inv(I+L); T = I-S; % Plot the results: % step response plots step(T);title('\alpha and \theta command step responses');

% frequency response plots figure; sigma(L,'r--',Gd,'k-.',Gd/GAM,'k:',Gd*GAM,'k:',{.1,100}) legend('\sigma(L) loopshape',... '\sigma(Gd) desired loop',... '\sigma(Gd) \pm GAM, dB');

figure; sigma(T,I+L,'r--',{.1,100}) legend('\sigma(T) robustness','1/\sigma(S) performance')

The number ±GAM, dB (i.e., 20log10(GAM)) tells you the accuracy with which your loopsyn control design matches the target desired loop:

format: plain


text:
# Let there be the function f(alpha)= (L( v_a - v_0 sin alpha))/(v_0 cos alpha) Where L ,v_a and v_o are constants. Determine alpha such that f(alpha) is minimal ?

Jul 5, 2018

$f \left(\alpha\right) = \frac{L \left({v}_{a} - {v}_{0} \sin \alpha\right)}{{v}_{0} \cos \alpha}$

$= L \left({v}_{a} / {v}_{o} \sec \alpha - \tan \alpha\right)$

$L$ is just a scaling factor so it can be removed, thus writing:

• $F \left(\alpha\right) = f \frac{\alpha}{L} q \quad F ' \left(\alpha\right) = \frac{f ' \left(\alpha\right)}{L} q \quad \text{ etc }$

To optimise $F \left(\alpha\right)$, differentiate wrt $\alpha$:

• ${F}_{\alpha} = {v}_{a} / {v}_{o} \sec \alpha \tan \alpha - {\sec}^{2} \alpha = 0$

$\implies {\underbrace{{\sec}^{2} \alpha}}_{> 0 , \forall \alpha} \left({v}_{a} / {v}_{o} \sin \alpha - 1\right) q \quad = \square q \quad = 0$

Critical points can, therefore, only occur under these rules:

• $\sin \alpha = {v}_{o} / {v}_{a} q \quad q \quad \implies \left\{\begin{matrix}{v}_{o} < = {v}_{a} \\ \cos \alpha = \frac{\sqrt{{v}_{a}^{2} - {v}_{o}^{2}}}{v} _ a \\ \tan \alpha = {v}_{o} / \sqrt{{v}_{a}^{2} - {v}_{o}^{2}}\end{matrix}\right.$

To determine the max or min nature of the Critical Point, grab the second derivative of $\square$, using the product rule:

${F}_{\alpha \alpha} = \left(2 {\sec}^{2} \alpha \tan \alpha\right) \left({\underbrace{{v}_{a} / {v}_{o} \sin \alpha - 1}}_{= 0}\right) + {\sec}^{2} \alpha \left({v}_{a} / {v}_{o} \cos \alpha\right)$

$= {\sec}^{2} \alpha \left({v}_{a} / {v}_{o} \cos \alpha\right) = {v}_{a} / {v}_{o} \sec \alpha$

$\therefore {F}_{\alpha \alpha} = \textcolor{b l u e}{{v}_{a} / {v}_{o}} \cdot \frac{1}{\textcolor{g r e e n}{\sqrt{1 - {v}_{o}^{2} / {v}_{a}^{2}}}}$

With assumption ${v}_{o} < = {v}_{a}$, then the green term is positive; whole expression is positive provided ${v}_{a} , {v}_{o} > 0$.

Accordingly, there is a min when this occurs:

• $\sin \alpha = {v}_{o} / {v}_{a}$

This min will be periodic.

I have solved this way. See the answer below:


text:
# Tag Info

1

Above the surface, we contain liquids and solids in concave vessels, openings pointed up, and tilt them to pour contents. Below the surface, you can contain gases in concave vessels, openings pointed down, and tilt them to pour contents (at least for non-water-soluble gases; wouldn't work well at all for ammonia, hydrogen halides, or hydrogen sulfide/sulfur ...

8

They could absolutely get to space. "Rocket science" isn't a complex field of science: it's just ballistics and some straightforward chemistry. What's fiendishly complex is the precision engineering and manufacturing required to go, not just into space, but where you mean to go with very little margin for error. What this means is that initially your ...

3

Relativity becomes significant for either very large masses or very high velocity. No big impact until they deploy the equivalent of our GPS satellite network, or start equipping satellites with very precise clocks. At that point they will notice that clocks on the ground and clocks high up in space will measure different times. But nothing dramatic ...

2

So, sweet treepeople... you need a way past that pesky armor eh? We have a warrior in our myths we call the "Spider-Man." He often fought foes more experienced, better armored and equipped than he. Perhaps your warriors have heard similar myths and wish to fight as the cunning spider. Your best advantage (given your light gear) is your mobility, and your ...

4

OK, slightly left field answer to this one. Assuming you are in an equivalent ocean to Earth's, you're never going to need to do your chemistry purely underwater. You have a water surface, you have underwater vents, fish have swim bladders etc. If you are careful you can "harvest" these, with anything waterproof (intestines, etc). You may even be able to ...

4

The ease with which information could be obtained would depend on the details of the environment and might be seriously limited. The “easiest” situation would be a civilization based in a shallow sea with access to the materials of the coast and access to the surface. Harder would be a civilization based in a deep sea far from land. And the hardest would be ...

26

I think you are on the right track and this is a really fun question. I think the issues you mentioned with things like generating heat are much larger obstacles than doing chemistry in a fluid medium would be. For an aquatic-native race, anyway. I'm going to focus mostly on the last part of your question, "What would their developmental path look like?" ...

10

During my PhD years I had to work with some materials which were quite reactive: as soon as they were exposed to oxygen or water they reacted very vigorously with them, leaving the poor student with a damaged sample or, even worse, with a sample which spontaneously took fire. A solution for handling these materials and keep the students alive was to use ...

2

This turned in to a little longer than a comment could handle, but here are some thoughts I have as an amateur astronomer: It's not unusual to see a dozen or more satellites on a clear, dark evening. Just a few nights ago I was walking across the street and noticed two at once. If it's dark enough to see the Milky Way and you're paying attention to the sky, ...

5

NASA has no reason to try to hide a satellite and all the current answers are working from a basis of a non-stealthy satellite. If someone is trying to hide a recon sat they certainly could do so until the late 20th century. Build the satellite with all Earth-visible surface (other than the minimum needed for whatever sensors it uses) as black (both to ...

2

Spotting the satelite and observing its orbit would have been possible since ancient times. Understanding what they are is a different thing. They are too fast to discern by telescope so they will be dismissed as fast-moving asteroids at a low orbit. With a good telescope you can have a good detailed image as well. However, they are too fast to allow us to "...

37

As many other comments have suggested, orbit altitude is a key parameter in determining how visible the recon satellite would be. However, orbital altitude also determines how long the object will stay in orbit—specifically the perigee (lowest-point) altitude. Let's say the recon satellite was in a roughly-circular¹ orbit of 400km, which is approximately ...

14

I think you have to ask (and answer) multiple questions. When will it be detected as a recurring object in the sky? L.Dutch suggests the naked eye will do; that might depend on the size and height of orbit. When will it be recognized as an artificial object? Here you should keep in mind that it has always been there. People will come up with theories of the ...

3

Many kinds of plant provide oils and waxes that might help waterproof your heartvine equipment. It'll be awkward to make stuff like pitch or tar without access to suitable materials for the cooking containers, but you might be able to use the shells from some of the local animal species for this purpose. There may also be animal sources of waxes, oils and ...

0

The simplest answer is that after skillfully (and possibly at the cost of one or more of your troupe's lives) dispatching one or more of your pangolin-like predators, you turn the armoured scales, claws and teeth of your now-dead adversary into the weapons which which you dispatch further such adversaries... which has the potential, depending upon their ...

55

Artificial satellites orbiting around Earth are pretty easy to spot, since they appear as bright fast moving objects across the night sky. This even in a light polluted environment like a modern city. I remember I spotted satellites moving in the sky as a kid looking up at the sky with no knowledge of astronomy. Spotting them was even more exciting than ...

1

Use bones I think bone is the best material for many kinds of weaponry because it's hard, can be sharpened, and will not be destroyed by water. Make spears and atlatls with them. Use human bones if animal bones are too small. Combine with heart vines to make them even more deadly. Eating cooked bones, including small ones such as those from chickens, can ...

4

Vine splinter slingshots Using some form of hand protection, vine splinters can be made into a ball shape and then wrapped in leaves. These can then be shot from slingshots. Upon hitting a person, the ball breaks apart and cuts into them, where they begin to grow inside of them dangerously. Poisoned cinder moss You have stated that cinder moss causes ...

2

This depends very much on which people are included in that "minimum population" and how closely they're concentrated. A quarter billion could probably do it in a space like the continental United States -- that's about what our population was twenty years ago (Alaska and Hawaii don't count for population on this scale; the two combined equal one large city ...

-2

Not all countries and companies have the same technology so I think you have to pick what technologies you want to keep, take the population of a country which has the closest set but smallest population and then add the employees of the companies that posses the remaining technologies you want to keep. Keep in mind though that some technologies will become ...

1

Canals: Simply having good, standardized, well-maintained canals should do the trick. With roads on the sides so that draft animals (or people) can tow the barges against or without winds. Where locks are required, they have the standard size to allow standard barges through. Ocean Craft: Improved rigging. There was a lot going on, all the way to the 20th ...

3

Domesticated animals Humans are not very strong animals, so in our history our productivity took a big step up when we learned to domesticate animals and extract their superior muscle power. Canals have never been a fast way to travel, but they were a lot faster than eighteenth-century roads, and one horse could 'carry' an awful lot more load pulling a ...

2

On the sea, the best you can get is sail ships, if you're not willing to accept steam as an option. If you want to speed that up a bit, make sure your people have discovered and mapped Ocean currents. As for cannals, apart from oars, you can also go for paddlewheels. Yeah, paddlewheel ships, but not ones running on steam, but ones running on animal power. ...

1

Technological reform without social reform can be less than successful. You know why we call plumbing by that name? The word literally comes from the Latin for Lead; they used the metal for their water management throughout the empire because it was cheap, malleable and easy to manage as a resource. There is some evidence available to say that the Romans ...

0

This is not an answer to what the OP asked, but it's something about teletransportation that always bothered me. It may be useful in OP's plot. Teleportation means death. Even when no demons are generated, all your matter is disassembled into particles and then vanishes. You die on departure. What is reassembled on the other terminal is a copy of you, that ...

0

Every passanger will carry a camera with him. He/she reaches a secured place, hands out the camera through a special compartment to the security team. The team analyzes the recording of the entire teleportation process and searches suspicious activities. The camera is embedded into the passenger's wear, so that it will not draw the demon's attention and ...

0

In the comments, I pointed out that teleportation breaks the universe by allowing infinite energy. Infinite energy (which breaks a WHOLE lot of universes): Build very tall tower, line a shaft with copper coils. Teleport huge magnets into the top of the tower, then let them drop down the shaft. The relevant parts of the response (in chat, so few people ...

1

The Johnson Rectifier. Scientist Maria Johnson pulled logs from teleporter machines that caused demon events (many brave people died to gather these logs) and discovered a fluctuation in the quark pump, every time. She invented a quark pump filter and since then, no teleporter equipped with one has had a demon encounter--unless the filter was damaged.

1

There is no real side-effect., except for occasional hangover-like symptoms and few broken fragile items. The whole thing is a scam, used to remove unwanted people and steal valuable parcels.

1

Nested teleporters. If your teleport goes awry, just teleport the whole room into space. Then go retrieve your teleporter in 12 days.

2

If you're wanting the teleportation technology to be widely used, then you're going to need to keep some secrets. I'd probably say that the cover is that teleportation causes a low-level of radiation: The schematics of the teleporters are closely-guarded industrial secrets. The utility of the process would generate revenue, giving you a "teleportation lobby"...

2

In an effort to solve a completely unrelated problem, I put a little something on an Excel sheet. It should be transcribed correctly here (unless it's not). With $p$, the probability it backfires $n$, the number of uses $q$, the probability it backfires at least once within $n$ uses It gives $q=1-(1-p)^n$ , as I said the probability it backfires at least ...

1

Why risk human teleportation at all? Robots have been an effective means of exploring the universe for decades, and still make up the majority of our exploration team - and if a demon does manifest from one of these robots, well-armed robots are more than capable of dispatching such a creature, with only the loss of some equipment. Teleportation would ...

1

It will not affect development of the technology at all... not until the problem is discovered. This wonderful technology was adopted extremely quickly, and it was only some years later when the first demon came out that people suddenly had to backpedal, scale down use, and retrofit protection devices on existing devices. Total abandonment is not possible ...

2

Put it on jupiter orbit or further and you can travel back in time. Why? Well "instant" travel from physics perspective is the speed of causality (=speed of light). You probably know about time dilation - the faster you travel, the slower your time relative to observers in destination. If you traveled somehow at the speed of light, the route would be ...

0

Usage: Only if ABSOLUTELY necessary. However, if it is necessary to use it, here are a few general safety precautions: Quarantine in a low-oxygen, nitrogen-free atmosphere. Seperate quarantine chambers for every living thing. This is because, believe it or not, we actually produce a small amount of nitrogen when we exhale. As a result, the quarantine is ...

30

Seems like infinity energy, just teleport some stuff and there are chances you get something that would never die and doesn't need much to survive. Stick that demon into a large hamster wheel facing some people and BAM, unstopping energy generator. Just hope the demons doesn't break out.

14

All teleported goods and passengers are kept in nitrogen free quarantine for 11 days and observed for signs of extradimensional naughtiness. Either in vacuum, or in a low pressure pure oxygen atmosphere, depending on which is least damaging to the thing you're sending. People can't breathe pure oxygen at Earth sea level pressure, but we can breathe pure ...

1

The answer depends on many details. First, assuming the technology has just been invented, is the percentage of demonization even an accurate number? It is one thing to say "we have to maintain the quux field within a range of 15 angstroms (and we can do it reliably 98% of time), else bad guys are coming out of woodwork on the receiving end" vs "we ...

31

In a real emergency, maybe you can convince somebody to hop in, but it should be noted that for all we know getting dumped into the hell dimension is a fate much worse than death. Instead, I suggest we just keep using regular 'ole chemical rockets. But, the teleporter is still really useful here. Assuming the energy cost is paid at the sending end (you ...

3

The usage would be varied, but I think the primary uses would be for material movement and for special forces. Teleporters would be a fantastic supply chain tool. A way to get a big box of rations or bullets across great distances that cannot be interfered with by opposing forces is a fantastic advantage to the Empire. Create your box of goodies as a ...

3

Passengers: Its usage will be affected by not doing living things unless absolutely necessary. General anti-demon rules: Teleportation to friendlies is as a rule done towards a receivingpad without the controls to teleport. In case a demon takes posession of the material (say a crate of plasma weapons or something similarily harmless if it came alive) the ...

69

It was weaponized. The military now have the ability to teleport sufficiently large numbers of items to an enemy city (or key military facility, spaceship etc.) to trigger a demon invasion. No need for tricky-to-handle plutonium to destroy the enemy, just teleport them a few thousand packs of, say, Stay-Puft marshmallows.

65

The teleport "conversion" was solved for military ships by the simple expedient of putting the teleport receiver inside an armored compartment with a large, fast-opening door -- to vacuum. Any received transmission is interrogated in a manner that has been developed to provoke "demons" -- but is reasonably harmless to humans or other legitimate payload -- ...

1

Just gonna try and throw an idea that isn't what you don't want. How about recording data of past events where there was previously no observer? Sending back a data recording device one second so it could record from past events that were missed by the interested party. This could have forensic applications. But what is 1 second to forensic scientist? Not ...

2

No. First you are sending back the wrong people, and secondly you are sending back too few of them. And finally, 21st century technology is dependent on 21st century population. It is utterly impossible without either more people than could be put under control in that timeframe or more advanced knowledge than we currently have... Now, if you want 20th ...

2

In the 1632 series they have something of the same situation but 6 mile radius bit of USA moved from the year 2000 (or near it) and with it a town with all schools up to a high school, many small and some mid sized businesses, a power plant with enough staff to run it and so on. They land in the middle of Germany (as is now) in an area with many people who ...

1

A Resounding YES As per the OP's question, we only need to replicate the 21st Century and populate it, we don't need to make the same mistakes, trial and errors, wars, dead end results or bad theories/misconceptions that normal development requires. Many developments that constitute the modern structure of society have been developed in the last 100 years. ...

1

It would definetly be possible All you need is humans and 10000 members is quite a large number. lets say, in worst case 1/3 are old people 1/3 are children, 1/3 are adults lets take the adult women from the equation, and you would have at least 1600 men to do the heavy work needed to start the industrial revolution. Which is not bad. The children ...

2

Since one progress made right after another is just not how human minds work, no, not in 100 years. Instead of thinking in number-of-years think in generations. You can hyper progress one generation, lets say from hunter-gathering to farming but then you have to stop. Let dust settle. Make people see fruits of their efforts. The next generation would make ...

Top 50 recent answers are included


text:
# Sh:677

• Shelah, S., & Spinas, O. (2000). On incomparability and related cardinal functions on ultraproducts of Boolean algebras. Math. Japon., 52(3), 345–358.
• Abstract:
Let C denote any of the following cardinal characteristics of Boolean algebras: incomparability, spread, character, \pi-character, hereditary Lindelöf number, hereditary density. It is shown to be consistent that there exists a sequence \langle B_i:i<\kappa\rangle of Boolean algebras and an ultrafilter D on \kappa such that C(\prod_{i<\kappa}B_i/D)<|\prod_{i<\kappa}C(B_i)/D|. This answers a number of problems posed by Monk.
• Version 2000-06-08_10 (16p)
Bib entry
@article{Sh:677,
author = {Shelah, Saharon and Spinas, Otmar},
title = {{On incomparability and related cardinal functions on ultraproducts of Boolean algebras}},
journal = {Math. Japon.},
fjournal = {Mathematica Japonica},
volume = {52},
number = {3},
year = {2000},
pages = {345--358},
issn = {0025-5513},
mrnumber = {1796651},
mrclass = {03E35 (03E05 03E55 03G05 06E05)},
note = {\href{https://arxiv.org/abs/math/9903116}{arXiv: math/9903116}},
arxiv_number = {math/9903116}
}


text:
Vol. 282, No. 2, 2016

 Recent Issues Vol. 287: 1 Vol. 286: 1  2 Vol. 285: 1  2 Vol. 284: 1  2 Vol. 283: 1  2 Vol. 282: 1  2 Vol. 281: 1  2 Vol. 280: 1  2 Online Archive Volume: Issue:
 The Journal Editorial Board Officers Special Issues Submission Guidelines Submission Form Subscriptions Contacts Author Index To Appear ISSN: 0030-8730
Exhausting curve complexes by finite rigid sets
257–283

Javier Aramayona and Christopher J. Leininger

A variational characterization of flat spaces in dimension three
285–292

Giovanni Catino, Paolo Mastrolia and Dario D. Monticelli

Estimates of the gaps between consecutive eigenvalues of Laplacian
293–311

Daguang Chen, Tao Zheng and Hongcang Yang

Liouville type theorems for the $p$-harmonic functions on certain manifolds
313–327

Jingyi Chen and Yue Wang

Cartan–Fubini type rigidity of double covering morphisms of quadratic manifolds
329–339

Hosung Kim

On the uniform squeezing property of bounded convex domains in $\mathbb C^n$
341–358

Kang-Tae Kim and Liyou Zhang

Lefschetz pencils and finitely presented groups
359–388

Ryoma Kobayashi and Naoyuki Monden

Knot homotopy in subspaces of the 3-sphere
389–414

Yuya Koda and Makoto Ozawa

On the relationship of continuity and boundary regularity in prescribed mean curvature Dirichlet problems
415–436

Kirk E. Lancaster and Jaron Melin

Bridge spheres for the unknot are topologically minimal
437–443

Jung Hoon Lee

On the geometric construction of cohomology classes for cocompact discrete subgroups of SL$_n(\mathbb{R})$ and SL$_n(\mathbb{C})$
445–477

Susanne Schimpf

On Blaschke's conjecture
479–485

Xiaole Su, Hongwei Sun and Yusheng Wang

The role of the Jacobi identity in solving the Maurer–Cartan structure equation
487–510


text:
# Tutor needed for R programming help PAID tutor opportunity

#### statsman101

##### New Member
Hi my name is Sam. I am looking for a statistics tutor who is familiar with the R programming language.

I have some questions that I need help with and they are in the R programming software. I can compensate you for your time. I can scan and email you the questions I need help with. I will need your help starting Monday November 17 till Friday November 21 for an assignment.

#### statsman101

##### New Member
How much do you pay?
Hi The assignment shouldn't take more than an hour, two hours at Max. I can offer 25 an hour.

#### statsman101

$25 us currency per hour. The assignment would take one hour or at max 2. It will be all using the R software. #### GretaGarbo ##### Human Well, statsman, there seems to be a competition. Someone else is offering 100-150 US$ per hour for a longer project. (And a longer project is worth more than a short one, given a fixed rate per hour.)

How much cakes can you buy for 25 US\$, baked or no-baked? (I can't remember which one is the preferred one.)

Edit: I believe that the cakes are supposed to be "baked".

Last edited:

#### Khrisstian

##### Member
Greta has made the point very clear that this isn't terribly enticing.

I do less interesting and productive things for free, though, so I can help out under one condition: You elaborate what exactly your Outcomes and Objectives are.