voting | A simulator for voting systems

There is no in-built provision to implement aggregation algorithms in Vertex AI. To curl results from the models then aggregate them, we would need to deploy all of them to individual endpoints. Instead, I would suggest the below method to deploy the models and the meta-model(aggregate model) to a single endpoint using custom containers for prediction. The custom container requirements can be found here.

You can load the model artifacts from GCS into a custom container. If the same set of models are used (i.e) the input models to the meta-model do not change, you can package them inside the container to reduce load time. Then, a custom HTTP logic can be used to return the aggregation output like so. This is a sample custom flask server logic.

Use:

It seems to be on the roadmap in Themes of .NET for .NET 7:

• Epic - Support Windows 11 look and feel for WPF controls

Also this amazing piece of open-source just landed:

• WPF UI - Windows 11 styles and controls for WPF

No, every binary floating-point number has an exact representation in decimal.

The numbers that can be represented exactly in binary floating-point (with a finite number of bits) are precisely those rational numbers which can be written with a denominator which is a power of 2, i.e. x = a/2ⁿ for integers a and n.

The numbers that can be represented exactly in binary floating-point (with a finite number of digits) are precisely those rational numbers which can be written with a denominator which is a power of 10, i.e. y = b/10ⁿ.

But every number from the first category is also in the second category, since a/2ⁿ = a•5ⁿ/10ⁿ.

More generally, every number with an exact representation in base u will also have an exact representation in base v, if and only if every prime factor of u is also a prime factor of v. This will ensure that 1/uⁿ can be written as a/v^m for some a and m.

This explains the asymmetry: 2 is prime, and the prime factors of 10 are 2 and 5. So every prime factor of 2 is a prime factor of 10, but not the other way around.

In order to interact with an ERC20 token, you have to create an instance of it from the desired contract. You would need to import ERC20 to your nfts contracts, and then create an ERC20 token instance pointing to your token. It would be something like this:

I believe there's a bug in your code on this line:

this call is wrong:

Great questions, let me answer them one-by-one:

What kind of KNN is it using?

I'm not entirely sure what you mean by "what kind", but I think this will be answered through the remaining questions. One thing to keep in mind is that Weaviate's kNN classification makes use of the existing vector index for a particular class. So depending on whether you brought your own vectors or used a model for vectorization, the input parameters will determine what the classification runs on. For example, if you are using a text2vec module on a text property with the name description, then those descriptions will be used to find the closest matches.

is it using simple voting or distance weighted voting?

As of v1.8.0 it's simple voting. Distance weighted voting might be a nice addition for the future.

is it using cosine distance?

As mentioned in the first answer, whatever settings you chose for your class will also apply to the classification. As of v1.8.0 Weaviate typically uses cosine distance, but there are plans to add other distance metrics in the near future.

does it use a method to find possible neighbors or use brute force to find all true nearest neighbors?

Similarly to above, it follows the settings of the class. Typically it uses an HNSW approximate index. You can tune its parameters on a class level.

what are winning/losing groups and how are they used to predict the class of a new vector?

They are a tool to gain some insights into why a classification resulted in the way that it did. The winning group is the "group" of results that had the highest votes and therefore lead to the item being classified as such. The losing groups (there can be multiple) are alternative "groups" which didn't get the highest vote. Knowing each group might be a good insight to tweak k for future classifications.

Since you are selecting bits of data from different levels of the input objects, you will need to specify the selection more precisely.

As your input consists of a stream of JSON objects, let's start with a function for reading one of those objects: