web-dev-qa-db-ja.com

2つの文字列の類似性を測定するにはどうすればよいですか?

2つの文字列text1およびtext2

public SOMEUSABLERETURNTYPE Compare(string text1, string text2)
{
     // DO SOMETHING HERE TO COMPARE
}

例:

  1. 最初の文字列:StackOverflow

    2番目の文字列:StaqOverflow

    戻り値:類似度は91%です

    戻り値は、%またはそのようなものになります。

  2. 最初の文字列:単純なテキストテスト

    2番目の文字列:複雑なテキストテスト

    戻り値:値は等しいと見なすことができます

何か案は?これを行う最良の方法は何ですか?

55
Zanoni

これにはさまざまな方法があります。アルゴリズムがある他のページへのリンクについては、 ウィキペディアの「文字列の類似性測定」ページ をご覧ください。

私はこれらのアルゴリズムのいずれも音を考慮しないとは思いませんが、「staq overflow」は「stack overflow」と同様に「stack overflow」に似ています最初は発音の面で似ているにもかかわらず、「staw overflow」。

私はちょうど見つけました 別のページ これはかなり多くのオプションを提供します...特に、 Soundex アルゴリズム(- Wikipedia )はより近いかもしれませんあなたは後です。

42
Jon Skeet

レーベンシュタイン距離 はおそらくあなたが探しているものです。

27
LiraNuna

ここに私が取り組んでいるプロジェクトのために書いたコードがあります。文字列のSimilarity Ratioと文字列の単語に基づくSimilarity Ratioを知る必要があります。この最後の1つは、最小文字列の単語類似率(すべての単語が存在し、より大きな文字列に一致する場合、結果は100%になる)と、より大きな文字列の単語類似率(RealWordsRatioと呼ぶ)の両方を知りたい)。レーベンシュタインアルゴリズムを使用して距離を見つけます。これまでのところ、コードは最適化されていませんが、期待どおりに機能します。役に立つと思います。

public static int Compute(string s, string t)
    {
        int n = s.Length;
        int m = t.Length;
        int[,] d = new int[n + 1, m + 1];

        // Step 1
        if (n == 0)
        {
            return m;
        }

        if (m == 0)
        {
            return n;
        }

        // Step 2
        for (int i = 0; i <= n; d[i, 0] = i++)
        {
        }

        for (int j = 0; j <= m; d[0, j] = j++)
        {
        }

        // Step 3
        for (int i = 1; i <= n; i++)
        {
            //Step 4
            for (int j = 1; j <= m; j++)
            {
                // Step 5
                int cost = (t[j - 1] == s[i - 1]) ? 0 : 1;

                // Step 6
                d[i, j] = Math.Min(
                    Math.Min(d[i - 1, j] + 1, d[i, j - 1] + 1),
                    d[i - 1, j - 1] + cost);
            }
        }
        // Step 7
        return d[n, m];
    }

double GetSimilarityRatio(String FullString1, String FullString2, out double WordsRatio, out double RealWordsRatio)
    {
        double theResult = 0;
        String[] Splitted1 = FullString1.Split(new char[]{' '}, StringSplitOptions.RemoveEmptyEntries);
        String[] Splitted2 = FullString2.Split(new char[]{' '}, StringSplitOptions.RemoveEmptyEntries);
        if (Splitted1.Length < Splitted2.Length)
        {
            String[] Temp = Splitted2;
            Splitted2 = Splitted1;
            Splitted1 = Temp;
        }
        int[,] theScores = new int[Splitted1.Length, Splitted2.Length];//Keep the best scores for each Word.0 is the best, 1000 is the starting.
        int[] BestWord = new int[Splitted1.Length];//Index to the best Word of Splitted2 for the Splitted1.

        for (int loop = 0; loop < Splitted1.Length; loop++) 
        {
            for (int loop1 = 0; loop1 < Splitted2.Length; loop1++) theScores[loop, loop1] = 1000;
            BestWord[loop] = -1;
        }
        int WordsMatched = 0;
        for (int loop = 0; loop < Splitted1.Length; loop++)
        {
            String String1 = Splitted1[loop];
            for (int loop1 = 0; loop1 < Splitted2.Length; loop1++)
            {
                String String2 = Splitted2[loop1];
                int LevenshteinDistance = Compute(String1, String2);
                theScores[loop, loop1] = LevenshteinDistance;
                if (BestWord[loop] == -1 || theScores[loop, BestWord[loop]] > LevenshteinDistance) BestWord[loop] = loop1;
            }
        }

        for (int loop = 0; loop < Splitted1.Length; loop++)
        {
            if (theScores[loop, BestWord[loop]] == 1000) continue;
            for (int loop1 = loop + 1; loop1 < Splitted1.Length; loop1++)
            {
                if (theScores[loop1, BestWord[loop1]] == 1000) continue;//the worst score available, so there are no more words left
                if (BestWord[loop] == BestWord[loop1])//2 words have the same best Word
                {
                    //The first in order has the advantage of keeping the Word in equality
                    if (theScores[loop, BestWord[loop]] <= theScores[loop1, BestWord[loop1]])
                    {
                        theScores[loop1, BestWord[loop1]] = 1000;
                        int CurrentBest = -1;
                        int CurrentScore = 1000;
                        for (int loop2 = 0; loop2 < Splitted2.Length; loop2++)
                        {
                            //Find next bestword
                            if (CurrentBest == -1 || CurrentScore > theScores[loop1, loop2])
                            {
                                CurrentBest = loop2;
                                CurrentScore = theScores[loop1, loop2];
                            }
                        }
                        BestWord[loop1] = CurrentBest;
                    }
                    else//the latter has a better score
                    {
                        theScores[loop, BestWord[loop]] = 1000;
                        int CurrentBest = -1;
                        int CurrentScore = 1000;
                        for (int loop2 = 0; loop2 < Splitted2.Length; loop2++)
                        {
                            //Find next bestword
                            if (CurrentBest == -1 || CurrentScore > theScores[loop, loop2])
                            {
                                CurrentBest = loop2;
                                CurrentScore = theScores[loop, loop2];
                            }
                        }
                        BestWord[loop] = CurrentBest;
                    }

                    loop = -1;
                    break;//recalculate all
                }
            }
        }
        for (int loop = 0; loop < Splitted1.Length; loop++)
        {
            if (theScores[loop, BestWord[loop]] == 1000) theResult += Splitted1[loop].Length;//All words without a score for best Word are max failures
            else
            {
                theResult += theScores[loop, BestWord[loop]];
                if (theScores[loop, BestWord[loop]] == 0) WordsMatched++;
            }
        }
        int theLength = (FullString1.Replace(" ", "").Length > FullString2.Replace(" ", "").Length) ? FullString1.Replace(" ", "").Length : FullString2.Replace(" ", "").Length;
        if(theResult > theLength) theResult = theLength;
        theResult = (1 - (theResult / theLength)) * 100;
        WordsRatio = ((double)WordsMatched / (double)Splitted2.Length) * 100;
        RealWordsRatio = ((double)WordsMatched / (double)Splitted1.Length) * 100;
        return theResult;
    }
14
ThunderGr

C#のDouble Metaphone実装 しばらく前に書きました。 Soundexなどに比べて非常に優れていることがわかります。

レーベンシュタイン距離も提案されており、多くの用途に最適なアルゴリズムですが、音声マッチングは実際にはそうではありません。音声的に類似した単語も通常は同じように綴られるため、そのように思われることがあります。 さまざまなファジーマッチングアルゴリズムの分析 を行いました。

5
anelson

「似たような音」に対処するには、Double Metaphoneやsoundexなどの音声アルゴリズムを使用したエンコードを検討することをお勧めします。音声エンコードされた文字列でレーベンシュタイン距離を計算することが有益かどうかはわかりませんが、可能性があるかもしれません。または、文字列内の各単語をエンコードされた形式に変換し、両方の文字列に出現する単語を削除して、レーベンシュタイン距離を計算する前に単一の表現に置き換えるなどのヒューリスティックを使用できます。

4
bdk

レーベンシュタイン距離 などの文字列「距離」を探すことができます。

3
schnaader

Perlモジュール Text :: Phonetic には、さまざまなアルゴリズムの実装があります。

3
Sinan Ünür

ジェフ・アトウッドが同様の解決策を探すことについて書いた Wiki投稿の著者を決定するため、検索を絞り込むのに役立ちます。

2
John Sheehan

SQLデータベースの値を比較する場合は、[〜#〜] soundex [〜#〜]関数を使用できます。 GoogleにSOUNDEXとC#を照会すると、一部の人々はそれとVBに対して同様の関数を作成しました。

2
Rob

音声的に比較したい場合は、SoundexおよびMetaphoneアルゴリズムを確認してください。 http://www.blackbeltcoder.com/Articles/algorithms/phonetic-string-comparison-with-soundex

1
Jonathan Wood

Soundexもお勧めします。過去にスペルミスの都市名を処理するために使用しました。使用方法についての適切なリンクを次に示します。 http://whitepapers.zdnet.com/abstract.aspx?docid=35295

1
pmatah

Metaphone 3は、Metaphoneアルゴリズムの第3世代です。北米でよく知られている最も一般的な英語の単語、名前、および英語以外の単語のデータベースと比較して、音声符号化の精度がDouble Metaphoneの89%から98%に向上します。これにより、アメリカの発音に対して非常に信頼性の高い音声エンコードが生成されます。

Metaphone 3は、元のMetaphoneおよびDouble Metaphoneアルゴリズムを設計および開発したLawrence Philipsによって設計および開発されました。

1
bjan