similarity | Text similarity calculation Toolkit | Natural Language Processing library

Note, for simplicity, let's assume you committed the change and are comparing commits; the result will be the same whether you diff beforehand with --staged or afterward using the commits.

Why is the output of git diff for this file different depending on whether I call it with or without the filename?

Think of the file specification as a lens in which to view the diff through.

When viewing the two commits in their entirety, Git sees:

• Commit 1 contains filename F1 with contents of blob B1 with hash H1, and does not contain F2.
• Commit 2 contains filename F2 with contents of blob B1 with hash H1, and does not contain F1.

Git sees that F1 and F2 are pointing to the same blob and since F1 is gone, and F2 appears with the same blob, Git can infer that is a rename. If the file was also edited, Git can do heuristics (which is configurable, btw), to determine if the differences between the blobs are close enough to still call it a rename.

When viewing the two commits through the filename lens, Git sees:

• Commit 1 does not contain F2.
• Commit 2 contains filename F2 with contents of blob B1 with hash H1.

Git sees this as an add.

What can you do?

You could make the lens larger to include both filenames. Using your example syntax for staging the move, consider these statements:

Hi here's my suggestion and I will edit it later to provide you with more information

Since its a sequence problem you should use RNN based models: LSTM, GRU's

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

In reference to the notebook you provided which is a supporting artefact to and implements ideas from the following two papers

1. "SVCCA: Singular Vector Canonical Correlation Analysis for Deep Learning Dynamics and Interpretability". Neural Information Processing Systems (NeurIPS) 2017
2. "Insights on Representational Similarity in Deep Neural Networks with Canonical Correlation". Neural Information Processing Systems (NeurIPS) 2018
   

The authors there calculate 50 = min(A_fake neurons, B_fake neurons) components and plot the correlations between the transformed vectors of each component (i.e. 50).

With the help of the below code, using sklearn CCA, I am trying to reproduce their Toy Example. As we'll see the correlation plots match. The sanity check they used in the notebook came very handy - it passed seamlessly with this code as well.

Maybe this is a possible solution. Given the following data:

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)):

Summary: we define two sketch functions f and g from entries to sets of “sketches” such that two entries e and e′ are similar if and only if f(e) ∩ g(e′) ≠ ∅. Then we can identify merges efficiently (see the algorithm at the end).

I’m actually going to define four sketch functions, f_os, f_addr, g_os, and g_addr, from which we construct

• f(e) = {(x, y) | x ∈ f_os(e), y ∈ f_addr(e)}
• g(e) = {(x, y) | x ∈ g_os(e), y ∈ g_addr(e)}.

f_os and g_os are the simpler of the four. f_os(e) includes

• (1, e.os), if e.os is known
• (2,), if e.os is known
• (3,), if e.os is unknown.

g_os(e) includes

• (1, e.os), if e.os is known
• (2,), if e.os is unknown
• (3,).

f_addr and g_addr are more complicated because there are prioritized attributes, and they can have multiple values. Nevertheless, the same trick can be made to work. f_addr(e) includes

• (1, h) for each h in e.hostname
• (2, m) for each m in e.mac, if e.hostname is nonempty
• (3, m) for each m in e.mac, if e.hostname is empty
• (4, i) for each i in e.ip, if e.hostname and e.mac are nonempty
• (5, i) for each i in e.ip, if e.hostname is empty and e.mac is nonempty
• (6, i) for each i in e.ip, if e.hostname is nonempty and e.mac is empty
• (7, i) for each i in e.ip, if e.hostname and e.mac are empty.

g_addr(e) includes

• (1, h) for each h in e.hostname
• (2, m) for each m in e.mac, if e.hostname is empty
• (3, m) for each m in e.mac
• (4, i) for each i in e.ip, if e.hostname is empty and e.mac is empty
• (5, i) for each i in e.ip, if e.mac is empty
• (6, i) for each i in e.ip, if e.hostname is empty
• (7, i) for each i in e.ip.

The rest of the algorithm is as follows.

• Initialize a defaultdict(list) mapping a sketch to a list of entry identifiers.

• For each entry, for each of the entry’s f-sketches, add the entry’s identifier to the appropriate list in the defaultdict.

• Initialize a set of edges.

• For each entry, for each of the entry’s g-sketches, look up the g-sketch in the defaultdict and add an edge from the entry’s identifiers to each of the other identifiers in the list.

Now that we have a set of edges, we run into the problem that @btilly noted. My first instinct as a computer scientist is to find connected components, but of course, merging two entries may cause some incident edges to disappear. Instead you can use the edges as candidates for merging, and repeat until the algorithm above returns no edges.

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:

To concatenate the two DataFrames horizontally, I aligned the Employees DataFrame by the index of the matched Vendor Name. If no Vendor Name was matched, I just put an empty row instead.

In more details:

• I iterated over the vendor names, and for each vendor name, I added the index of the employee name with the highest score to a list of indices. Note that I added at most one matched employee record to each vendor name.
• If no match was found (too low score), I added the index of an empty record that I have added manually to the Employees Dataframe.
• This list of indices is then used to reorder the Employees DataDrame.
• at last, I just merge the two DataFrame horizontally. Note that the two DataFrames at this point doesn't have to be of the same size, but in such a case, the concat method just fill the gap with appending missing rows to the smaller DataFrame.

The code is as follows: