Neuropype Version: 2023.0.1

  • Minor bugfixes and improvements to the Neuropype engine and nodes.

Neuropype Version: 2023.0.0

New Node packages:

  • Array: nodes for working with arrays (one or multiple dimensions) directly rather than with Neuropype packets. Covers most linear algebra needs.
  • ControlFlow: nodes which can be used to implement non-linear control flow such as looping, conditional processing, and functions.
  • DeepLearning: nodes which can be used to implement deep learning workflows, including training and inference.
  • Distributions: nodes which can be used to create various kinds of common probability distributions and compute their quantities (mean, variance, entropy, etc.)or draw samples from the distribution.
  • Optimizations: nodes related to optimization algorithms (i.e., Gradient, Jacobian, etc.).
  • Programming: nodes which implement operations for handling the essential data structure types in programming languages (strings, lists, dictionaries, etc.), and are useful to provide the functional "glue" in a more complex processing workflow.
  • Random: nodes for drawing samples from random distributions and for managing random seeds and chainable keys.

New Engine Features:

  • Support for creating deep neural networks and workflows, including convolution layers, dense layers, normalizations, activations, optimizers, schedules, cross validation, etc. Comprehensive deep learning models, such as EEGNET, can now be expressed as a Neuropype pipeline.
  • Support for running deep learning operations on the GPU (requires installing an additional set of GPU-enabled libraries including CUDA), with support for jax, pytorch, and tensorflow.
  • Most math operation nodes now support other backends in addition to numpy (jax, tensorflow, dask, cupy, pydata.sparse, pytorch), for GPU computation.
  • Support for looping within a pipeline (see ForEach, Continue, Break, etc. in the ControlFlow package).
  • Support for conditional branching and execution (see IfElse, Switch, etc. in the ControlFlow package).
  • Support for defining functions (and lambdas) inside a pipeline using python and math methods (see Function, Lambda, etc. in the ControlFlow package, and the Programming package).
  • Support for exception handling in a pipeline (see Except, Throw, etc. in ControlFlow package).
  • Neuropype is now turing complete!
  • Support for an extensive set of array-based operations (see new nodes added to ElementWise package).
  • Most ElementWise nodes can now operate on data types other than Packets (i.e., ints, floats, arrays, etc.).
  • Nodes which have an axis parameter now support specifying the axis label so as to select a specific axis (i.e., if multiple axes of same type in Packet).
  • Enhanced debugging support including viewing history ("time-travel" debugging) (see engine/breakpoints.py).
  • Many performance and other enhancements

New Nodes:

  • Array package:
    • ArrayNonzero: Get the indices or optionally n-dimensional index coordinates of the non-zero entries in an array.
    • ArrayNonzero: Get the indices or optionally n-dimensional index coordinates of the non-zero entries in an array.
    • ArrayReshape: Change the shape of an array without changing the number of elements.
    • CreateDiagonal: Create a diagonal matrix from a vector, or stack of vectors.
    • CreateIdentity: Create a two-dimensional array that is an identity matrix, optionally with a shifted diagonal.
    • CreateIntegerRange: Create a raw array that contains an arithmetic progression of numbers with integer step size.
    • CreateLinearRange: Create a raw array that contains an arithmetic progression of numbers with real-valued step size and starts/ends.
    • CreateOnes: Create a raw numeric array of a given shape filled with ones.
    • CreateZeros: Create a raw numeric array of a given shape filled with zeros.
    • MatrixCholesky: Calculate the lower Cholesky decomposition of a complex Hermitian or real symmetrix positive- definite matrix, or a stack of matrices.
    • MatrixDeterminant: Calculate the determinant of the given square matrix, or stack of matrices.
    • MatrixDiagonal: Obtain the diagonal vector of a matrix or stack of matrices.
    • MatrixEigh: Calculate an eigenvalue decomposition of a complex Hermitian or real symmetric positive-definite matrix or stack thereof.
    • MatrixInverse: Calculate the multiplicative inverse of the given matrix, or stack of matrices.
    • MatrixKron: Take the Kronecker product of two matrices or stacks of matrices.
    • MatrixLeastSquares: Compute the least-squares solution to a linear matrix equation A * X = B or stacks thereof.
    • MatrixMultiply: Multiply two matrices or stacks of matrices.
    • MatrixPinv: Calculate the Moore-Penrose pseudo-inverse of a matrix or stack of matrices.
    • MatrixQR: Calculate the QR decompoisition of a matrix or stack thereof.
    • MatrixRank: Calculate the rank of a given matrix or stack of matrices.
    • MatrixSVD: Calculate the singular value decomposition (SVD) of a matrix or stack of matrices.
    • MatrixSolve: Solve a linear matrix equation A * X = B or system of linear equations, or stacks thereof.
    • MatrixTrace: Calculate the trace (sum of diagonal elements) of a matrix or stack of matrices.
    • MatrixTranspose: Transpose the given matrix or stack of matrices.
  • Control_flow package:
    • ArrayForEach: Apply the loop body to each slice of an array or packet along some axis and stack the results along some axis.
    • Bind: Bind arguments to positional or named parameters in the given function or graph.
    • Break: Break out of the current loop.
    • ByReference: Pass a given value by reference into the next node.
    • Call: Call/apply a function with some arguments.
    • Continue: Skip the rest of the current loop cycle and continue with the next loop iteration, if any.
    • Except: Evaluate the try body while guarding for exceptions.
    • Fold: Fold elements of a collection or iterable using a function that successively combines (reduces) the elements with an initial value.
    • FoldCollect: A variant of the Fold loop node that additionally collects a secondary output of the loop body in each iteration and stacks them into an array or Packet.
    • ForEach: Apply a function or loop body to each item in a collection or iterator.
    • Function: Declare a function.
    • GraphPlaceholder: A placeholder that can accept a graph or callable function.
    • IfElse: If-else conditional control flow aka conditional computation.
    • Lambda: Create an anonymous (lambda) function.
    • ParallelForEach: Parallel version of the ForEach node.
    • Placeholder: Declare a named placeholder in a graph.
    • Result: Declare an output as the result of the graph.
    • Sequential: Ensure that the paths wired into the node are evaluated in a specified order.
    • Switch: Switch expression for conditional control.
    • Throw: Throw an Exception.
  • Deep_learning package:
    • AMSGradStep: The AMSGrad optimizer step.
    • Activation: Apply an elementwise non-linear neural network activation function to the given data.
    • AdaBeliefStep: The AdaBelief optimizer step.
    • AdaFactorStep: The AdaFactor optimizer step.
    • AdagradStep: The Adagrad optimizer step.
    • AdamStep: The Adam optimizer step.
    • AdamWStep: The AdamW optimizer step (adam with weight decay).
    • AdamaxStep: The Adamax optimizer step.
    • AdamaxWStep: The AdamaxW optimizer step (adamax with weight decay).
    • AdditiveNoiseStep: Chainable step that adds Gaussian noise to the gradients.
    • AggregateStep: A modifier for the step node that is wired into it which accumulates k successive gradient evaluations and passes them to the optimizer for use in one summed (or averaged) update.
    • ApplyIfFiniteStep: A modifier of the step node that is wired into it, which prevents NaN or infinite or inf updates from going through unless the max_consecutive_errors has been exceeded, in which case the update goes through.
    • BatchFlatten: Flatten all axes of the input tensor except for the batch dimension (n leading dimensions).
    • BatchNorm: Apply batch normalization to the given data.
    • BatchReshape: Reshape input tensor preserving the batch dimension.
    • CenteringStep: Chainable step that centers the gradients (subtracts their mean).
    • ChainedStep: Compose a sequence of gradient processing steps into a single update step.
    • ConstantInitializer: An initializer that always returns the same constant value.
    • ConstantSchedule: A constant parameter schedule.
    • ConstraintStep: Chainable step that allows parameters or gradients to be constrained by projecting them into the desired form.
    • ConvolutionLayer: A 1/2/3/N-D standard convolution layer.
    • CosineDecaySchedule: A cosine decay schedule.
    • CosineOneCycleSchedule: A one-cycle cosine ramp up/down parameter schedule.
    • CustomInitializer: A custom initializer that is defined by a computational graph that takes in a shape and data type (string) and returns an array of the given shape/type.
    • CustomSchedule: A custom schedule that is defined by a graph function that takes in a step count and returns a parameter value.
    • CustomStep: A custom optimizer step that is defined by a graph applied to gradients and, optionally, current weights.
    • CyclicCosineDecaySchedule: A cyclic linear warmup followed by cosine decay schedule.
    • DPSGDStep: The differentially private SGD (DPSGD) optimizer step.
    • DeepModel: A deep-learning based machine learning model.
    • DenseLayer: Dense neural network layer.
    • DepthwiseConvolutionLayer: A 1/2/3/N-D depthwise convolution layer.
    • DepthwiseSeparableConvolutionLayer: A 1/2/3/N-D depthwise separable convolution layer.
    • Dropout: Apply dropout regularization to the data.
    • EmbeddingLayer: A trainable layer for mapping categorical (integer) data to low-dimensional vectors.
    • ExponentialDecaySchedule: An exponential decay (or growth) schedule.
    • FromageStep: The Fromage (Frobenius Matched Gradient Descent) optimizer step.
    • GatedRecurrentUnitLayer: A gated recurrent unit (GRU) recurrent core, based on Chung et al.
    • GradientClippingStep: Chainable step that clips incoming gradients based on their norm, ensuring that the gradient norm does not exceed a provided threshold.
    • GroupNorm: Apply group normalization to the given data.
    • IdentityInitializer: An initializer that initializes the array to an identity matrix or stacks thereof (where the last two dimensions are the identity matrix).
    • InstanceNorm: Apply instance normalization to the given data.
    • LAMBStep: The LAMB optimizer step.
    • LARSStep: The LARS optimizer step.
    • LayerNorm: Apply layer normalization to the given data.
    • LinearOneCycleSchedule: A one-cycle linear ramp up/down parameter schedule.
    • LinearSchedule: A linear parameter schedule.
    • LongShortTermMemoryLayer: A long short-term memory (LSTM) recurrent layer, based on Hochreiter and Schmidhuber (1997).
    • MomentumStep: Chainable step that adds momentum based on one of several formulations, including classic momentum, Nesterov acceleration, and exponential moving average.
    • MultiHeadAttentionLayer: A multi-head attention layer.
    • NetDefine: Define a neural network module (subnet).
    • NetForward: Define a neural network module (subnet).
    • NetInitialize: Get initial weights and optionally state for a network that has been transformed to functional form.
    • NetMaterialize: Materialize a network module (subnet), which allows it to be wired into a larger computational graph along with input placeholders and other nodes (incl.
    • NetShare: Reuse a materialized network in a computational graph.
    • NetTransform: Transform a computational graph that involves neural net nodes into a functional form, with weights threaded out.
    • NetWeightArray: Define network weight array.
    • NoisySGDStep: The NoisySGD optimizer step.
    • NormalInitializer: An initializer that draws initial weights from a Gaussian normal distribution with a given mean and standard deviation.
    • NovoGradStep: The Novograd optimizer step.
    • NullStep: A no-op gradient update step that can be used to explicitly freeze weights.
    • OptimisticGDStep: The Optimistic gradient descent optimizer step.
    • OrthogonalInitializer: An initializer that generates a random matrix of orthogonal vectors.
    • PartitionedStep: Apply a set of steps to different labeled subsets of the parameters, using a separately provided labeling dictionary, yielding a composite update step.
    • PiecewiseConstantSchedule: A piecewise-constant parameter schedule.
    • PiecewiseInterpolatedSchedule: A piecewise interpolated parameter schedule.
    • PolynomialSchedule: A polynomial parameter schedule.
    • Pooling: Perform an N-dimensional spatial pooling operation (average or max) on the given data.
    • RAdamStep: The Rectified Adam optimizer step.
    • RMSNorm: Apply RMS normalization to the given data.
    • RMSPropStep: The RMSProp optimizer step.
    • RecurrentLoop: Loop a graph representing a recurrent neural network across an input array.
    • SGDStep: The Stochastic Gradient Descent (SGD) optimizer step.
    • SM3Step: The SM3 optimizer step.
    • ScalingStep: Chainable step that scales the gradients by a fixed or variable factor.
    • SequenceSchedule: A composite schedule that is a sequence of multiple provided schedules, each with a given starting step count.
    • StepApply: Apply an optimizer step to given gradients, prior state, and optionally prior weights.
    • StepInit: Get initial state for an optimization step.
    • TransposedConvolutionLayer: A 1/2/3/N-D "transposed" (upscaling) convolution layer.
    • TruncatedNormalInitializer: An initializer that draws initial weights from a truncated Gaussian distribution with a given mean and standard deviation.
    • TrustRatioScalingStep: A chainable step that scales gradients by the trust ratio.
    • UniformInitializer: An initializer that draws initial weights from a uniform distribution with a given minimum and maximum.
    • VarianceScalingInitializer: Initialize weights from a distribution whose scale is adapted to the shape of the initialized array.
    • WarmupCosineDecaySchedule: A linear warmup followed by cosine decay schedule.
    • WarmupExponentialDecaySchedule: A linear warmup followed by an exponential decay parameter schedule.
    • WeightDecayStep: Chainable step that applies weight decay (l2 regularization) to the parameters.
    • YogiStep: The Yogi optimizer step.
  • Diagnostics package:
    • Alert: Shows and/or sounds an alert if incoming values are a 1 (ON).
    • IsDebugMode: Determine if the pipeline is running in debug mode.
    • WithProfiler: Run the given computational graph with profiling enabled.
  • Distributions package:
  • Elementwise_math package:
    • ArcCos: Calculate the inverse cosine of each element in the data.
    • ArcCosh: Calculate the inverse hyperbolic cosine of each element in the data.
    • ArcSin: Calculate the inverse sine of each element in the data.
    • ArcSinh: Calculate the inverse hyperbolic sine of each element in the data.
    • ArcTan: Calculate the inverse tangent of each element in the data.
    • ArcTan2: Take the elementwise arc tangent (atan2) of the two given inputs.
    • ArcTanh: Calculate the inverse hyperbolic tangent of each element in the data.
    • ArrayAnd: Computes the elementwise AND operation between two or more objects.
    • ArrayNot: For each element in the data, take the logical negation (NOT) of the element.
    • ArrayOr: Computes the elementwise OR operation between two or more objects.
    • ArrayXor: Computes the elementwise XOR operation between two objects.
    • Cos: Calculate the cosine of each element in the data.
    • Cosh: Calculate the hyperbolic cosine of each element in the data.
    • EqualTo: For each array element in data1, test whether it is equal to the corresponding element in data2.
    • GreaterOrEqual: For each array element in data1, test whether it is greater than or equal to the corresponding element in data2.
    • GreaterThan: For each array element, test whether it is greater in data1 than in data2.
    • IsInfinite: Return an object of the same type and shape as the data that has, for each element, a boolean value indicating whether it was an infinity value.
    • IsNan: Return an object of the same type and shape as the data that has, for each element, a boolean value indicating whether it was a NaN value.
    • LessOrEqual: For each array element in data1, test whether it is less than or equal to the corresponding element in data2.
    • LessThan: For each array element, test whether it is less in data1 than in data2.
    • Modulo: Calculate the modulus (remainder) of a mod b.
    • NotEqualTo: For each array element in data1, test whether it is not equal to the corresponding element in data2.
    • ReciprocalSquareRoot: Take the reciprocal square root of each element in the data.
    • Sin: Calculate the sine of each element in the data.
    • Sinh: Calculate the hyperbolic sine of each element in the data.
    • Softmax: Apply the softmax function to the given data array.
    • SpecialFunction: Evaluate a mathematical special function elementwise for one or more array operands.
    • Tan: Calculate the tangent of each element in the data.
    • Tanh: Calculate the hyperbolic tangent of each element in the data.
    • Where: Select from one or another array elementwise, depending on an elementwise condition mask.
  • File_system package:
    • ExportText: Export a string to a file in plaintext format.
    • ImportText: Import a plaintext file into a string.
    • PathAbsolute: Make the given file path absolute if it is not yet.
    • PathExists: Check if the given path (file or directory) exists.
    • UploadFileToCloud: Upload a local file to your Neuroscale cloud storage or another cloud storage service.
  • Formatting package:
    • CreateAxis: Create a new named axis for a block, with a singleton value.
    • CreateBlock: Create a new block ((multi-dimensional array with named/typed axes).
    • CreateChunk: Create a new chunk (pairs a Black with a dictionary of descriptive properties.
    • CreatePacket: Create a packet (a collection of chunks, each with an associated name).
  • Machine_learning package:
    • ConvexModel: A flexible convex optimization based machine learning model.
  • Neural package:
  • Nirs package:
  • Optimization package:
    • BoxConstraint: A constraint projection forcing the given solution to lie inside an n-dimensional box.
    • ClusteredPenalty: A penalty encouraging the patterns along individual rows of the solution matrix to condense into few similar stereotypical patterns.
    • CosineDistanceLoss: Calculate the cosine distance between vector predictions and vector targets.
    • FunctionTransform: Apply a library-based transformation to a graph and invoke the resulting graph with some arguments.
    • Gradient: Calculate the gradient for a given graph with respect to one or more of its parameters.
    • GroupSparsePenalty: A penalty encouraging group-sparse solutions with groups corresponding to the entries along one or more axes.
    • HingeLoss: Calculate the Hinge loss between predictions and target values.
    • HuberLoss: Calculate the robust Huber loss between predictions and regression target values.
    • Jacobian: Calculate the Jacobian matrix for a given graph with respect to one or more of its parameters.
    • KLDivergenceLoss: Calculates the KL divergence between a predicted/proposed discrete probability distribution and a target/known distribution.
    • LBFGSSolve: Iteratively solve a smooth nonlinear optimization problem using the L-BFGS method.
    • LinearEqualityConstraint: A constraint projection forcing the given solution vector to satisfy a linear matrix equation Ax=b.
    • LinearSolve: Solve a linear system of equations of the form Ax=b.
    • LogCoshLoss: Calculate the robust log-cosh loss between predictions and regression targets.
    • LowRankPenalty: A penalty encouraging solution matrices or tensors that are low rank with respect to two or more axes.
    • NonnegativeConstraint: A constraint projection forcing the given solution to have no negative elements.
    • NonnegativeSumConstraint: A constraint projection forcing the given solution to sum to a constant value, with all values being non-negative.
    • NonuniformGroupSparsePenalty: A penalty encouraging group-sparse solutions along one or more axes with non-uniform group sizes, implemented as a proximal operator.
    • NormConstraint: A constraint projection forcing the given solution to have a norm of at most or exactly the given scale.
    • OverlappingGroupSparsePenalty: A penalty encouraging group-sparse solutions along one or more axes with overlapping and non-uniform group sizes.
    • ParameterOptimization: Optimize hyper-parameters of a pipeline given a dataset.
    • PerformanceMetric: Calculate one of a set of performance metrics between predictions and target values.
    • PlaneConstraint: A constraint projection forcing the given solution to lie on a plane in N-dimensional space or in a half-space bounded by the plane.
    • SigmoidBinaryCrossEntropyLoss: Calculate a cross-entropy loss with either binary labels or multi-class labels andlogit predictions.
    • SoftmaxCrossEntropyLoss: Calculate a softmax cross-entropy loss between logit predictions and integer target labels or a label distribution.
    • SparsePenalty: A penalty encouraging sparse solutions, as a proximal operator for the classic l1 norm.
    • SquaredLoss: Calculate a squared error between predictions and regression target values.
    • ValueAndGradient: Calculate the function value and gradient for a given graph with respect to one or more of its parameters.
  • Programming package:
    • And: Logical AND operation.
    • BreakList: Destructure a list into multiple items.
    • CastToGraph: Cast an object of unknown type to type graph.
    • CastToType: Cast the input value to a certain type.
    • ChainIterator: An iterator that emits first all elements of the first iterable, then all elements from the second iterable, etc.
    • ConstantComplex: Declare a complex-valied constant.
    • ConstantGraph: Declare a constant graph.
    • ConstantValue: Declare a constant of any type.
    • Contains: Check if the given object contains a specified item or, depending on context, field.
    • Copy: Make a shallow or deep copy of an object.
    • CreateDict: Create a dictionary from a list of names and values.
    • CreateIndexRange: Define an index range that can be used to select items from a collection, e.g
    • DictIterator: Iterate over a key/value pairs in a dictionary.
    • DictKeys: Get the keys of a dictionary as a list.
    • DictMerge: Merge one or more dictionaries, optionally allowing keys to be overridden by later dictionaries.
    • DictRemove: Get a dictionary with a specific item removed.
    • DictUpdate: Get a new dictionary in which specific name/value pairs have been overridden.
    • DictValues: Get the values of a dictionary as a list.
    • EnumerateIterator: An iterator that yields 2-element lists made up of an index and the next item from a source iterable.
    • Equal: Test whether two input objects are equal.
    • GetField: Access a field with a specific name on an object.
    • GetItem: Get the item with the specific key or index.
    • GetNested: Access a nested field or item of a specified object, i.e., within a Packet.
    • Hash: Compute a hash of a given piece of data.
    • IsOfType: Test whether the given object is of a specific type.
    • ListAppend: Append an item to a list.
    • ListCount: Count the number of occurrences of an item in a list.
    • ListFind: Find the first or last index for a given item.
    • ListFirst: Get the first item in a list.
    • ListFlatten: Flatten an arbitrarily nested list into a simple list.
    • ListInsert: Insert an item before a specific indexed item in a list.
    • ListLast: Get the last item in a list.
    • ListPrepend: Prepend an item to a list.
    • ListRemove: Get a list with a specific item removed.
    • ListRest: Get the remainder of a list excluding the first item.
    • ListSort: Sort the given list, optionally with a function that extracts a comparison key from a given list element (e.g
    • ListUnique: Reduce list to its unique items.
    • Not: Logical NOT operation.
    • NumElements: Get the number of elements in the given object.
    • Or: Logical OR operation.
    • PacketIterator: Iterate over the chunks and their names in a Packet.
    • Print: Print the given data.
    • RangeIterator: Iterate over a range of integers between start, and optionally stop, with a specified step size.
    • SetNested: Set a nested field or item of a specified object, i.e., within a Packet.
    • StringCheck: Check if the given string is of a specified type.
    • StringComparison: Determine the ordering of the first string relative to the second string.
    • StringEndsWith: Check if the given string ends with the provided suffix.
    • StringFind: Find the (zero-based) start index of a substring in a string.
    • StringIterator: Iterate over a characters of a string.
    • StringLower: Convert string to lower case.
    • StringRepeat: Repeat the given string n times.
    • StringSplit: Split a string into a list of strings based on a separator character or string.
    • StringSplitLines: Split a string into a list of strings at line boundaries.
    • StringStartsWith: Check if the given string starts with the provided prefix.
    • StringTrim: Trim whitespace or other characters from one or both ends of a string.
    • StringUpper: Convert string to upper case.
    • SubrangeIterator: An iterator that emits only a subrange of another iterable.
    • SystemInformation: Queries a property of the ambient runtime system.
    • Xor: Logical XOR operation.
    • ZipIterator: An iterator that iterates over two or more source iterators and emits a list of items.
  • Random package:
    • CreateRandomSeed: Create a (splittable) random seed for deterministic random number generation.
    • DeriveRandomSeed: Derive a new random seed from an initial seed and some data.
    • DrawRandomSeed: Draw a random seed from the currently sequence of deterministic random seeds, if one is set.
    • RandomGamma: Draw an array of random numbers from a gamma distribution with a given mean and standard deviation, optionally matching a template array in shape and optionally data type.
    • RandomIntegers: Draw an array of random integers from a uniform distribution.
    • RandomNormal: Draw an array of random numbers from a normal distribution.
    • RandomNumbers: Draw an array of random numbers from a defined distribution.
    • RandomPermute: Return an array that has the items in the given array permuted along the first axis.
    • RandomPoisson: Draw an array of random numbers from a Poisson distribution.
    • RandomSeedIterator: Iterate over an infinite series of random seeds that are derived form an initial seed.
    • RandomTruncatedNormal: Draw an array of random numbers from a truncated normal distribution.
    • RandomUniform: Draw an array of random numbers from a uniform distribution.
    • SplitRandomSeed: Manually split a random seed into an array of multiple derived seeds.
    • WithRandomSeed: Run the given computational graph with a random seed sequence initialized to the given seed.
  • Spectral package:
    • FastFourierTransform: Calculate the (one-dimensional) Fast Fourier Transform (FFT) of the given data along some axis.
    • InverseFastFourierTransform: Calculate a time-domain signal from its frequency representation using the inverse Fast Fourier Transform (IFFT).
  • Statistics package:
    • All: Test whether the given data has all non-zero or True values along an axis.
    • Any: Test whether the given data has any non-zero or True value along an axis.
    • DescribeStatisticalDesign: Describe the statistical design for the given data.
    • MANCOVA: Calculate a (M)AN(C)OVA statistical model.
    • MahalanobisDistance: Calculate the Mahalanobis distance for some data points with respect to some mean and covariance.
    • Median: Compute the median of the data over a given axis.
    • MixedANOVA: Compute a mixed-design (split-plot) ANOVA.
    • MixedEffectsANOVA: Create a linear mixed model, which allows 'random' effects in addition to the standard 'fixed' effects.
    • MultipleComparisonCorrection: Correct p-values for multiple comparisons (multiple dependent variables).
    • PairwiseComparisons: Calculate all pairwise multiple comparisons for each factor plus optional interactions using Tukey HSD.
    • Product: Compute the product along a given axis.
    • RMANOVA: Compute a repeated measures ANOVA.
    • StandardDeviation: Compute the standard deviation of the data over a given axis.
  • Tensor_math package:
    • SeparateAxisElements: Separate the given axis elements into new axis elements (used to expand an axis).
    • Sort: Sort the data along an axis.
    • VectorCross: Compute the cross product of two sets of vectors represented by the given axis in the data.
    • VectorDot: Compute the dot product (inner product) of two sets of vectors represented by the given axis in the data.
    • VectorNorm: Compute a norm of the vectors represented by the given axis.
  • Utilities package:
    • BlockReset: Prevents subsequent nodes from receiving a reset signal from the preceding node.
    • DiscardEmptyData: Discard data that is empty.
    • HoldLastValue: Holds (and passes on) the most recently received non-empty value.
    • OneHotCoding: Convert the given integer data to a one-hot coding.
    • ReplaceAxisValues: Replace the values in an array of an axis, such as channel or feature names.
    • SelectInstanceFields: Select (retain) or drop fields from an instance axis.
    • TaskNumber: Retrieve the number of this task if run as part of a parallel collection of tasks.
    • WithBackend: Run the given computational graph with a specified compute backend and precision.
    • WithCache: Cache (or retrieve) the results of a computational chain of nodes.
    • WithCoreLimit: Run the given computational graph with a limit on the number of cores that can be used by the process.

Renamed/Deprecated Nodes:

  • The old names are retained as alias nodes in the deprecated package:
  • RenameAxisValues --> ReplaceAxisValues

Node Features:

  • RDetection: Fix type, out of range errors; indicate when buffering
  • HeartRate, HeartRateVariability, RespRate: set unit as a property
  • DirectDirectedTransferFunction: support for frequencies passed in as an array; mitigation of div/0 risks
  • CognionicsInput: support for Linux; support for latest CGX headset, option to turn electrode LEDs on/off; store device info in stream properties (metadata)
  • ChannelDiagnostics: uses channel impedance (if available) to compute bad channel classification; outputs values via ports (for broadcasting over LSL, i.e., to plot on a remote computer); correlation threshold is now a range; added option to exclude line noise when computing high freq. noise score; bad channel classification can now indicate whether high freq. noise is the only cause of it being classified as bad (safely ignored in some cases).
  • EegQualityMetrics: added ability to adjust line noise SNR over time; can now export list of bad channels to be removed/interpolated downstream; added notch filter and convolution_method params; cut preringing on high pass filter by default
  • NoDataAlert: optionally send alerts in form of markers (i.e., to send out over LSL to remote computer)
  • Print, PrintToConsole: better formatted output; option to output to disk
  • Round: returns precision along with result
  • ToDecibels: replace 0 values with epsilon to avoid -inf results
  • ExportCSV: singleton axes no longer have to be stripped upstream
  • ExportSET: support for exporting ICA fields as well as back projection for EEG.data
  • ImportCSV: cloud_host supports HTTPS to import file directly from the web; support for importing files without a header row; can import stats data as a dataframe (see dependent_variable_columns param); support to specify modality, quantity, unit of incoming data
  • ImportEDF: handle files without a raw_units array; sets unit and modality in stream props; option to exclude specified channels on import
  • ImportFile: support for caching
  • ImportSET: load ICA matrices if present in file
  • ImportXDF: uses original streamnames by default
  • PathIterator: option to retain original order of paths found
  • RecordToXDF: new output_path port to pass the full output path to another node (i.e., UploadFileToCloud); improved channel location info for EEG and NIRS data; data block type forced to float64
  • RenameStreams: option to drop all streams that are not specified in rename list
  • AccumulateCalibrationData: include first and last sample of calibration data
  • MeasureLoss: new data output formats that includes statistics along with loss values; node no longer passes data through (only outputs loss)
  • Machine Learning Nodes (LogisticRegression, etc.): more robust support for a wider range of scikit-learn models; preserve block axes in model weights
  • AddEventMarker: option to pass in a dictionary with a full set of criteria (i.e., loaded from disk or passed in via a ParameterPort)
  • InsertMarkers: can now specify which occurances of the target marker should be locked to
  • LSLInput: added option to name streams in Packet with original LSL streamnames instead of the signal modality (see use_streanames parameter)
  • ChannelRepair: added option to repair channel based on channel impedance (if available)
  • FilterBankCommonSpatialPattern: support for rectangular window
  • FixSignalUnit: option to skip unit calculation if already specified in Metadata.Unit stream property; if unit cannot be inferred, warns and passes data through (instead of raising an error)
  • AssignChannelLocations: store the montage used in the SpaceAxis.montage field
  • InterpolateMissingChannels: use montage specified in SpaceAxis.montage field, if specified, for forchannel interpolation
  • PreprocessEEG: the montage param is now montage_type, while montage can take a path to a custom montage to use; default highpass stop attenuation increased to 120
  • ReplaceThresholdedData: replace data with NaN if impedance > threshold
  • SpectrallyWeightedCommonSpatialPattern: better support for badly rank-deficient data
  • SourcePowerComodulation: store model as a Packet
  • FIRFilter: filter kernel can now be wired out as a Packet (to pass to another node); alternative implementation for gap-aware filtering
  • InfomaxICA: force input channel stream to be output as a source component stream; added variance explained to feature axis that uses pvaf method for computing; support for multicore/GPU backends; emits ICA matrices and activations stream
  • SignalWhitening: support for adapting only once
  • SpectralSelection: added support for stop-band gain, multiple backends
  • GroupedMean: instance axis elements can now be returned in order of theiroriginal appearance or sorted alphabetically
  • ConcatInputs: will now work out of the box with marker-only data
  • SelectRange: support for selecting from lists, arrays and strings (in addition to Packets); auto unit now selects the most common unit for an axis rather than inferring it from the data; instance-fields axis option dropped (now a separate node, SelectInstanceFields); integer options dropped from axis parameter (can be typed in the axis parameter)
  • SetAxisValues: changes to behavior in case of empty or non-existant arrays (see node docs)
  • StripSingletonAxis: added param to ignore target axis if not a singleton (pass through data unchanged)
  • CountAlongAxis: now supports arrays and lists; can be set to positive or negative integers; stream name accepts wildcards
  • SetStreamProperties: support wildcards for stream selection
  • TimeSeriesPlot, SpectrumPlot, BarPlot: refactored with numerous new features (see node docs); these plots now work with offline (recorded) data (i.e., to create a plot that is exported to an image); standardized features across all three nodes
  • ScrollPlot: major upgrade with many new features: jump to time, number of channels to display, scaling/autoscaling, show markers (with filtering), size and color options, etc.
  • InspectPacket: show human-readable stats axis labels based on numeric ParameterTypes (see constants.py)
  • MarkerStreamWindow: plot is closed/redrawn if signal changes to immediately see results while running pipeline

New Resources

  • new example pipelines in Examples folder
  • all example pipelines have been updated with more comments, features, etc. (some have been renamed)
  • additional sample nodes in Examples/Nodes (for writing your own nodes)
  • montage for biosemi-128 headset

Pipeline Designer: New Features

  • New status bar above the toolbar (bottom left); green indicates pipeline is running, blue when pipeline is paused, grey when no pipeline is running.
  • "Calibrating" message now shows in the new status bar (instead of in the canvas)
  • Run pipeline icon changes to "Pause" when a pipeline is running, and "Play" when paused
  • Use Control + mouse wheel to zoom in and out on the canvas.
  • Use Control-F to search for a node in the graph (input box is in the status bar), Control-G to find next (also added to Edit menu).
  • Many font and icon sizes can be changed in the Settings window (File | Settings, or press Control-Shift-I).
  • Color themes for node categories / packages (see Settings)
  • Node properties (parameters) are now grouped into categories in the node properties window (mouse over a category name to see its definition)
  • Expert parameters now turned on by default
  • Mousing over the input or output anchors on a node shows the definitions for that node's inputs or output ports
  • Mousing over an edge (link) between nodes shows the description of the ports that are connected