dominate | Declarative DOM building

I was able to make it work in C++11, but only by manually reinventing C++14's std::integer_sequence, and losing constexpr-ability:

Check if your web app on PythonAnywhere is set up to be run by Python 2.7 -- I see you're using pip install outside of a virtual environment which by default will use pip for Python 2.7 as you can see in the output (btw. it won't work on PythonAnywhere, you need to provide --user option). If you want to install packages outside of virtual environment for different version of Python, use pipX.X install --user ... (where X.X should be replaced by required Python version). Also, remember to reload the web app every time the setup is changed. And if you're really stuck, maybe try contacting PythonAnywhere support (support@pythonanywhere.com) or use their forums?

Is it possible to share your the saved model directory to me? I can help debugging.

The general advise is that, there are two possibilities that

(1) TF Lite converter may not handle the saved model correctly.

(2) onnx conversion tool may not create a valid TF saved model.

Using the recent TF version (2.5 or tf-nightly) might help resolve this problem in the (1) case but it's not guaranteed.

I confirmed that the tf-nightly version could convert the attached saved model without any issue:

I'd go for finding the top K value, following by a size comparison

1. Taking a list slice has the cost O(m) where m is the size of the slice. This is because it has to create a new list of size m and populate its entries.

2. On the first call, the slice is of size n/2. Inside the first recursive call, the slice taken is now of size n/4. And it continues to be reduced by 1/2 on each recursive call.The total cost of taking slices is therefore: O(n/2 + n/4 + n/8 + ...) = O(n) (by taking the sum of the geometric series).

The intuition behind the efficient greedy solution to this problem lies in the fact that a point i is dominated by point j iff x[i] > x[j] and y[i] > y[j], which implies that j must come before i when the points are ordered by either coordinate. Hence, if we traverse the points in increasing order of their x-coordinates, then the point j (if any) that dominates point i must have been traversed before point i is traversed. In other words, it is impossible for the dominating point j to come after the dominated point i in this ordering.

Thus, with this traversal order the domination problem (i.e. checking if a point is dominated by some other point) boils down to checking if we have already seen a point with a lower y-coordinate as the traversal order already enforces the x-coordinate condition. This can easily be done by checking each point's y-coordinate to the lowest (minimum) y-coordinate we have seen so far -- if the minimum y-coordinate is less than the current point i's y-coordinate then the point j with the minimum y-coordinate dominates i as x[j] < x[i] because j was seen before i.

Sorting by the x-coordinate takes O(n log n) time and checking each point (while maintaining the partial minimum y-coordinate) takes O(n) time, making the entire algorithm take O(n log n) time.

Use map in parse_text function so that you get lists separately.

Multi-headed attention was introduced due to the observation that different words relate to each other in different ways. For a given word, the other words in the sentence could act as moderating or negating the meaning, but they could also express relations like inheritance (is a kind of), possession (belongs to), etc.

I found this online lecture to be very helpful, which came up with this example:

"The restaurant was not too terrible."

Note that the meaning of the word 'terrible' is distorted by the two words 'too' and 'not' (too: moderation, not: inversion) and 'terrible' also relates to 'restaurant', as it expresses a property.

The correct answer is in the comments, but an esthete in me can't refrain from noting how much nicer this would look in a actual idiomatic scala :)