cosin | 春松客服，多渠道智能客服系统，开源客服系统 ，机器人客服 | Machine Learning library

Seems you need to apply your rotate function to offset points relative to rotated corner, but you have no angle value at this moment. So you can just get direction vectors from rotated sides.

You can build and use the C++ interface of Faiss library (see this).

If you just want L2 normalization of a vector in C++:

The part of the instrument audio that gives its distinctive sound, independently from the pitch played, is called the timbre. The modern approach to get a vector representation, would be to train a neural network. This kind of learned vector representation is often called to create an audio embedding.

An example implementation of this is described in Learning Disentangled Representations Of Timbre And Pitch For Musical Instrument Sounds Using Gaussian Mixture Variational Autoencoders (2019).

Yes above code is for number, not for array of numbers.

You can convert Array of numbers into pyspark Vectors https://spark.apache.org/docs/latest/api/python/reference/api/pyspark.ml.linalg.Vectors.html

And then call use dense and dot functions.

Example

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.

You can use get(object_name) to get an object by name

Two minor errors that's preventing you from looping through. For the second example, in the for loop you're only looping through index 0 and index (len(human_directory) - 1)). Instead, you should do for i in range(len(human_directory)): That should allow you to loop through both.

For the first, I think you might get some kind of too many values to unpack error. To loop through two iterables concurrently, use zip(), so it should look like

for human_file, api_file in zip(os.listdir(human_directory), os.listdir(api_directory)):

What is happening is:

• std::inner_product( a.begin(), a.end(), a.begin(), 0.f ) returns a temporary, whose lifetime normally ends at the end of the statement
• when you assign a temporary directly to a reference, there is a special rule that extends the life of the temporary
• however, the problem with: std::move( std::inner_product( b.begin(), b.end(), b.begin(), 0.f ) ); is that the temporary is no longer assigned directly to a reference. Instead it is passed to a function (std::move) and its lifetime ends at the end of the statement.
• std::move returns the same reference, but the compiler doesn't intrinsically know this. std::move is just a function. So, it doesn't extend the lifetime of the underlying temporary.

That it appears to work with Clang is just a fluke. What you have here is a program exhibiting undefined behaviour.

See for example this code (godbolt: https://godbolt.org/z/nPGxMnrzf) which mirrors your example to some extent, but includes output to show when objects are destroyed:

The results are not surprising. You have passed two sentences which are very similar, but have opposite meanings. The sentence embeddings are obtained from a model trained on generic corpora, hence, the embeddings given by the model are generally expected to close to each other if the sentences are similar. And that's what is happening, that the cosine similarity shows that the embedding are close to each other and so is the sentence. The sentences in the example may have opposite meanings, but they are similar to each other.

In case, if you expect two similar sentences with opposite meaning to be far away from each other, then you have to further fine-tune the model with kind of classification model (such as sentiment analysis, if your examples are based on positive and negative sentiments). or with some other relevant task.