ContraD | Training GANs with Stronger Augmentations via Contrastive | Machine Learning library

In the documention of kafka about retries, it says:

Allowing retries without setting max.in.flight.requests.per.connection to 1 will potentially change the ordering of records because if two batches are sent to a single partition, and the first fails and is retried but the second succeeds, then the records in the second batch may appear first.

According the paragraph,if two batches are send to the same partition, kafka can commit the second batch while fail the first batch.
But this seems contradic to kafka's guarantee about ordering in same partition. Because usually if one batch failed, all subsequent batches should fail,otherwise how could it guarantee ordering? Besides,how does kafka guarantee that the order of batches send by producer is the same as the order reveiced by broker.

So my question is: how does kafka guarantee the ordering of different batch (of same partition) or it just does not guarantee.

I am trying to create a Hibernate Search representation of the StingUtils containsIgnoreCase() method together with fuzzy-search matching.

Assume the user writes the letter "p", and they will get all matches that include the letter "p" (regardless whether the letter is located at the beginning, middle or end of the respective matches).

As they form words such as "Peter", they should also receive fuzzy-matches as e.g."Petar", "Petaer" and "Peder" as well.

I am using the custom query and index Analyzers provided in the great answer here, because I need minGramSize at 1 to allow for the autocomplete functionality, while at the same time I also expect multi-word user input separated by white spaces such as "EUR Account of Peter", which can be in different cases (lower or upper).

So a user should be able to type "AND" and receive the above example as a match.

Currently, I am using the following query:

I have a large dataframe consisting of tweets, and keyword dictionaries loaded as values that have words associated with morality (kw_Moral) and emotion (kw_Emo). In the past I have used the keyword dictionaries to subset a dataframe to get only the tweets that have one or more of the keywords present.

For example, to create a subset with only those tweets that have emotional keywords, I loaded in my keyword dictionary...

I have a large dataframe consisting of tweets, and a keyword dictionary loaded as a list that has words and word stems associated with emotion (kw_Emo). I need to find a way to count how many times any given word/word stem from kw_Emo is present each tweet. In kw_Emo, word stems are marked with an asterisk ( * ). For example, one word stem is ador*, meaning that I need to account for the presence of adorable, adore, adoring, or any pattern of letters that starts with ador….

From a previous Stack Overflow discussion (see previous question on my profile), I was greatly helped with the following solution, but it only counts exact character matches (Ex. only ador, not adorable):

1. Load relevant package.

   library(stringr)

2. Identify and remove the * from word stems in kw_Emo.

   for (x in 1:length(kw_Emo)) { if (grepl("[*]", kw_Emo[x]) == TRUE) { kw_Emo[x] <- substr(kw_Emo[x],1,nchar(kw_Emo[x])-1) } }

3. Create new columns, one for each word/word stem from kw_Emo, with default value 0.

   for (x in 1:length(keywords)) { dataframe[, keywords[x]] <- 0}

4. Split each Tweet to a vector of words, see if the keyword is equal to any, add +1 to the appropriate word/word stems' column.

   for (x in 1:nrow(dataframe)) { partials <- data.frame(str_split(dataframe[x,2], " "), stringsAsFactors=FALSE) partials <- partials[partials[] != ""] for(y in 1:length(partials)) { for (z in 1:length(keywords)) { if (keywords[z] == partials[y]) { dataframe[x, keywords[z]] <- dataframe[x, keywords[z]] + 1 } } } }

Is there a way to alter this solution to account for word stems? I'm wondering if it's possible to first use a stringr pattern to replace occurrences of a word stem with the exact characters, and then use this exact match solution. For instance, something like stringr::str_replace_all(x, "ador[a-z]+", "ador"). But I'm unsure how to do this with my large dictionary and numerous word stems. Maybe the loop removing [*], which essentially identifies all word stems, can be adapted somehow?

Here is a reproducible sample of my dataframe, called TestTweets with the text to be analysed in a column called clean_text:

dput(droplevels(head(TestTweets, 20)))