wv | Read INSTALL for install information

As Justin said you aren't assigning the return value of os.path.join anywhere. This will create a path, but if you aren't doing anything with it, nothing happens.

You have to use the .write() function to write the file to the os.path.join return value.

This code should work.

When you perform a new call to .train(), it only trains on the new data. So only words in the new data can possibly be updated.

And to the extent that the new data may be smaller, and more idiosyncratic in its word usages, any words in the new data will be trained to only be consistent with other words being trained in the new data. (Depending on the size of the new data, and the training parameters chosen like alpha & epochs, they might be pulled via the new examples arbitrarily far from their old locations - and thus start to lose comparability to words that were trained earlier.)

(Note also that when providing an different corpus that the original, you shouldn't use a parameter like total_examples=model.corpus_count, reusing model.corpus_count, a value cahced in the model from the earlier data. Rather, parameters should describe the current batch of data.)

Frankly, I'm not a fan of this feature. It's possible it could be useful to advanced users. But most people drawn to it are likely misuing it, expecting any number of tiny incremental updates to constantly expand & improve the model - when there's no good support for the idea that will reliably happen with naive use.

In fact, there's reasons to doubt such updates are generally a good idea. There's even an established term for the risk that incremental updates to a neural-network wreck its prior performance: catastrophic forgetting.

The straightforward & best-grounded approach to updating word-vectors for new expanded data is to re-train from scratch, so all words are on equal footing, and go through the same interleaved training, on the same unified optimization (SGD) schedule. (The new new vectors at the end of such a process will not be in a compatible coordinate space, but should be equivalently useful, or better if the data is now bigger and better.)

Assuming you are working in SQL server, save your list of states in temp table #state_list and join it with country.

Select c.State from country c inner join #state_list sl on c.state = sl.state

I've not tried the nonsense parameter epochs=0, but it might behave as you expect. (Have you tried it and seen otherwise?)

However, if your real goal is to be able to tamper with the model after initialization, but before training, the usual way to do that is to not supply any corpus when constructing the model instance, and instead manually do the two followup steps, .build_vocab() & .train(), in your own code - inserting extra steps between the two. (For even finer-grained control, you can examine the source of .build_vocab() & its helper methods, and simply ensure you do all those necessary things, with your own extra steps interleaved.)

The "word vectors" in the .wv property of type KeyedVectors are essentially the "input projection layer" of the model: the data which converts a single word into a vector_size-dimensional dense embedding. (You can think of the keys – word token strings – as being somewhat like a one-hot word-encoding.)

So, assigning into that structure only changes that "input projection vector", which is the "word vector" usually collected from the model. If you need to tamper with the hidden-to-output weights, you need to look at the model's .syn1neg (or .syn1 for HS mode) property.

Try using word_vec.wv.vectors instead of word_vec.wv.syn0. That's the array holding the raw vectors.

(KeyedVectors hasn't had a true syn0 for a while but if it might have had a backward-compatibility alias at the time your code was 1st crafted.)

hjust = 0.5 should work better. Using hjust = 0 aligns your labels a little to the right, with the top edge of the text aligned with the middle of each peak.

Here's a reproducible example that doesn't rely on external data that might not remain available at that link. (See bottom for application to the OP dataset.)

In your implementation, in scaled_dot_product you scaled with query but according to the original paper, they used key to normalize. Apart from that, this implementation seems Ok but not general.

You need to change the conditions,

• change $gte to $gt
• change $lt to $lte

In order to comma separate the values (with .join(",") you need to get the option texts as an array.

One option is to use jquery's .map() to loop through each selected option and return its text in an array.

With no other changes, your code