uncertainty | Learning with uncertainty for biological discovery | Genomics library

You cannot access relationship properties directly via repositories. Those classes are just an encapsulation for properties on relationships and are not meant to represent a "physical" relationship or more a relationship entity. Repositories are for @Node annotated classes solely.

If you want to access and modify the properties of a relationship, you have to fetch the relationship defining entity. A relationship on its own is always represented by its start and end node.

The lately introduced required @Id is for internal purposes only. If you have a special need to persist an id-like property on the relationship, it would be just another property in the @RelationshipProperties annotated class.

You could use tidyverse:

Multi-collinearity isn't always a hindrance. It depends from data to data. If your model isn't giving you the best results(high accuracy or low loss), you then remove the outliers or highly correlated features to improve it but is everything is hunky-dory, you don't bother about them.

Same goes with polynomial regression. Yes it adds multi-collinearity in your model by introducing x^2, x^3 features into your model.

To overcome that, you can use orthogonal polynomial regression which introduces polynomials that are orthogonal to each other.

But it will still introduce higher degree polynomials which can become unstable at the boundaries of your data space.

To overcome this issue, you can use Regression Splines in which it divides the distribution of the data into separate portions and fit linear or low degree polynomial functions on each of these portions. The points where the division occurs are called Knots. Functions which we can use for modelling each piece/bin are known as Piecewise functions. This function has a constraint , suppose, if it is introducing 3 degree of polynomials or cubic features and then the function should be second-order differentiable. Such a piecewise polynomial of degree m with m-1 continuous derivatives is called a Spline.

The reason the first query is so much faster is it went parallel. This means the cardinality estimator knew enough about the data it had to handle, and the query was large enough to tip the threshold for parallel execution. Then, the engine passed chunks of data for different processors to handle individually, then report back and repartition the streams.

With the value as a variable, it effectively becomes a scalar function evaluation, and a query cannot go parallel with a scalar function, because the value has to determined before the cardinality estimator can figure out what to do with it. Therefore, it runs in a single thread, and is slower.

Some sort of looping mechanism might help. Create the included indexes to assist the engine in handling this request. You can probably find a better looping mechanism, since you are familiar with the identity ranges you care about, but this should get you in the right direction. Adjust for your needs.

With a loop like this, it commits the changes with each loop, so you aren't locking the table indefinitely.

You are using V3 syntax for the scales, version 2 used a different syntax, please look at this link for the documentation for the version you are using

Live example with scale min-max:

You've written:

It's more a process than a single event or piece of code, but here's a SQL query that can help. To isolate credit consumption cleanly, you need separate warehouses. It is possible, however, to estimate the credit consumption over time by user. It's an estimate because a warehouse is a shared resource, and since two or more users can be using a warehouse simultaneously the best we can do is figure a way to apportion who's responsible for what part of that consumption.

The following query estimates credit consumption by user over time using the following approach:

1. Each segment in time that a warehouse runs gets logged as a row in the SNOWFLAKE.ACCOUNT_USAGE.METERING_HISTORY view.
2. If only one user is active in the duration of that segment, the query assigns 100% of the usage to that user.
3. If more than one user is active in the duration of a segment, the query takes the total query run time for a user and divides it by the total query run time in that segment for all users. This pro-rates the shared warehouse by query runtime.

#3 is the approximation, but it's suitable if you don't use it for chargebacks or billing someone for data share usage.

Be sure to change the warehouse name to your WH name and set the start and end timestamps for the duration you'd like to check usage.

What's the advantage of having a datatype which size is platform dependent [...]?

It is the native (i.e. hardware defined) type of the platform. The underlying hardware has a certain bit width of its integer types (modern hardwares are 64 or 32 bits). It is sensible to have native == hardware types for a language which provides and allows low level optimisations.

So, you have the (15000,3) matrix accepted, where xi=accepted[:,0], mu=accepted[:,1] and sig=accepted[:,2].

I will generate some sample data for xi, mu and sig, just to show you the results of plotting.