pattern-matching - que - pattern matching traductor

Registros coincidentes basados en el nombre de la persona

Question

¿Existen herramientas o métodos que puedan usarse para hacer coincidir el nombre de una persona entre dos fuentes de datos diferentes?

Los sistemas no tienen otra información común y los nombres se han ingresado de manera diferente en muchos casos.

Ejemplos de coincidencias no exactas:

King Jr., Martin Luther = King, Martin (excluye el sufijo)
Erving, Dr. J. = Erving, J. (excluir prefijo)
Obama, Barak Hussein = Obama, Barak (excluye el segundo nombre)
Pufnstuf, HR = Pufnstuf, Haibane Renmei (abreviaturas de los partidos)
Tankengine, Thomas = Tankengine, Tom (hacer coincidir los apodos comunes)
Flair, Rick "the Natureboy" = Flair, Natureboy (coincide con el apodo)

Answer 1

Metaphone 3 es la tercera generación del algoritmo Metaphone. Aumenta la precisión de la codificación fonética del 89% de Double Metaphone al 98% , según se compara con una base de datos de las palabras en inglés más comunes y con nombres y palabras que no son en inglés que son familiares en América del Norte. Esto produce una codificación fonética extremadamente confiable para las pronunciaciones americanas.

Metaphone 3 fue diseñado y desarrollado por Lawrence Philips, quien diseñó y desarrolló los algoritmos originales Metaphone y Double Metaphone.

Answer 2

A menudo empleo algoritmos de tipo soundex para este tipo de situación. Pruebe el algoritmo de doble metáfono . Si está utilizando SQL Server, existe algún código fuente para crear una función definida por el usuario.

Debido a que ha transpuesto datos, es posible que desee normalizarlos un poco, por ejemplo, elimine todas las comas y ordene las palabras resultantes por primera letra. Eso te dará un mejor potencial de emparejamiento. En el caso de que se hayan agregado palabras en el medio, se vuelve un poco más difícil. Podría considerar dividir un nombre en palabras, verificando con Double Metaphone si hay una palabra en la otra columna que coincida, y luego recopilar el recuento total de coincidencias contra palabras, lo que le dirá qué tan cerca están las dos columnas.

También filtraría palabras comunes como Dr., Sr., Sra., Sra., Etc., antes de hacer las comparaciones.

Answer 3

Aquí hay algunas opciones:

Algoritmos fonéticos ...

Soundex ( http://en.wikipedia.org/wiki/Soundex )

Doble metáfono ( http://en.wikipedia.org/wiki/Double_Metaphone )

Editar distancia ( http://en.wikipedia.org/wiki/Levenshtein_distance )

Distancia Jaro-Winkler ( http://en.wikipedia.org/wiki/Jaro-Winkler_distance )

Otra cosa que podrías intentar sería comparar cada palabra (dividir en espacio y quizás un guión) con cada palabra del otro nombre y ver cuántas palabras coinciden. Tal vez combine esto con algoritmos fonéticos para una coincidencia más difusa. Para un conjunto de datos enorme, desearía indexar cada palabra y relacionarla con una identificación de nombre. Para la coincidencia de abreviaturas puede comparar solo la primera letra. Probablemente quieras ignorar todo lo que no sea letras cuando comparas palabras también.

Muchos de los algoritmos fonéticos tienen fuente abierta / muestras en línea.

Answer 4

Es un problema muy complejo, y hay muchas herramientas costosas para hacerlo correctamente.
Si alguna vez te has preguntado por qué no puedes registrarte en un vuelo como Tom, Dick o Harry (o Bill)
O por qué las listas de exclusión aérea y las listas de vigilancia de terroristas no funcionan. Considere:

(1) Muammar Gadafi
(2) Mo''ammar Gadhafi
(3) Muammar Kaddafi
(4) Muammar Qadhafi
(5) Moammar El Kadhafi
(6) Muammar Gadafi
(7) Mu''ammar al-Qadafi
(8) Moamer El Kazzafi
(9) Moamar al-Gaddafi
(10) Mu''ammar Al Qathafi
(11) Muammar Al Qathafi
(12) Mo''ammar el-Gadhafi
(13) Moamar El Kadhafi
(14) Muammar al-Qadhafi
(15) Mu''ammar al-Qadhdhafi
(16) Mu''ammar Qadafi
(17) Moamar Gaddafi
(18) Mu''ammar Qadhdhafi
(19) Muammar Khaddafi
(20) Muammar al-Khaddafi
(21) Mu''amar al-Kadafi
(22) Muammar Ghaddafy
(23) Muammar Ghadafi
(24) Muammar Ghaddafi
(25) Muamar Kaddafi
(26) Muammar Quathafi
(27) Muammar Gheddafi
(28) Muamar Al-Kaddafi
(29) Moammar Khadafy
(30) Moammar Qudhafi
(31) Mu''ammar al-Gadafi
(32) Mulazim Awwal Mu''ammar Muhammad Abu Minyar al-Qadhafi

Y eso es solo la ortografía oficial, ¡no incluye errores tipográficos!

Answer 5

Tuve que usar una variedad de técnicas sugeridas. Gracias apuntándome en la dirección correcta (s). Con suerte, lo siguiente ayudará a alguien más con este tipo de problema para resolver.

Eliminar el exceso de caracteres

CREATE FUNCTION [dbo].[fn_StripCharacters]
(
@String NVARCHAR(MAX),
@MatchExpression VARCHAR(255)
)
RETURNS NVARCHAR(MAX)
AS
BEGIN
SET @MatchExpression = ''%[''+@MatchExpression+'']%''
WHILE PatIndex(@MatchExpression, @String) > 0
SET @String = Stuff(@String, PatIndex(@MatchExpression, @String), 1, '''')
RETURN @String
END

Uso:

--remove all non-alphanumeric and non-white space
dbo.fn_StripCharacters(@Value, , ''^a-z^0-9 '')

Dividir el nombre en partes

CREATE FUNCTION [dbo].[SplitTable] (@sep char(1), @sList StringList READONLY)
RETURNS @ResultList TABLE
(
[ID] VARCHAR(MAX),
[Val] VARCHAR(MAX)
)
AS
BEGIN
declare @OuterCursor cursor
declare @ID varchar(max)
declare @Val varchar(max)
set @OuterCursor = cursor fast_forward for (SELECT * FROM @sList) FOR READ ONLY
open @OuterCursor
fetch next from @OuterCursor into @ID, @Val
while (@@FETCH_STATUS=0)
begin
INSERT INTO @ResultList (ID, Val)
select @ID, split.s from dbo.Split(@sep, @Val) as split
where len(split.s) > 0
fetch next from @OuterCursor into @ID, @Val
end
close @OuterCursor
deallocate @OuterCursor
CREATE FUNCTION [dbo].[Split] (@sep char(1), @s varchar(8000))
RETURNS table
AS
RETURN (
WITH Pieces(pn, start, stop) AS (
SELECT 1, 1, CHARINDEX(@sep, @s)
UNION ALL
SELECT pn + 1, stop + 1, CHARINDEX(@sep, @s, stop + 1)
FROM Pieces
WHERE stop > 0
)
SELECT pn,
LTRIM(RTRIM(SUBSTRING(@s, start,
CASE WHEN stop > 0
THEN stop-start
ELSE 8000
END))) AS s
FROM Pieces
)
RETURN

Uso:

--create split name list
DECLARE @NameList StringList
INSERT INTO @NameList (ID, Val)
SELECT id, firstname FROM dbo.[User] u
WHERE PATINDEX(''%[^a-z]%'', u.FirstName) > 0
----remove split dups
select u.ID, COUNT(*)
from dbo.import_SplitTable('' '', @NameList) splitList
INNER JOIN dbo.[User] u
ON splitList.id = u.id

Apodos comunes:

Creé una tabla basada en esta lista y la usé para unirme con nombres equivalentes comunes.

Uso:

SELECT u.id
, u.FirstName
, u_nickname_maybe.Name AS MaybeNickname
, u.LastName
, c.ID AS ContactID from
FROM dbo.[User] u
INNER JOIN nickname u_nickname_match
ON u.FirstName = u_nickname_match.Name
INNER JOIN nickname u_nickname_maybe
ON u_nickname_match.relatedid = u_nickname_maybe.id
LEFT OUTER JOIN
(
SELECT c.id, c.LastName, c.FirstName,
c_nickname_maybe.Name AS MaybeFirstName
FROM dbo.Contact c
INNER JOIN nickname c_nickname_match
ON c.FirstName = c_nickname_match.Name
INNER JOIN nickname c_nickname_maybe
ON c_nickname_match.relatedid = c_nickname_maybe.id
WHERE c_nickname_match.Name <> c_nickname_maybe.Name
) as c
ON c.AccountHolderID = ah.ID
AND u_nickname_maybe.Name = c.MaybeFirstName AND u.LastName = c.LastName
WHERE u_nickname_match.Name <> u_nickname_maybe.Name

Algoritmos fonéticos (Jaro Winkler):

El asombroso artículo, Más allá de SoundEx - Funciones para la búsqueda aproximada en MS SQL Server , muestra cómo instalar y usar la biblioteca SimMetrics en SQL Server. Esta biblioteca le permite encontrar una similitud relativa entre cadenas e incluye numerosos algoritmos. Terminé usando principalmente a Jaro Winkler para hacer coincidir los nombres.

Uso:

SELECT
u.id AS UserID
,c.id AS ContactID
,u.FirstName
,c.FirstName
,u.LastName
,c.LastName
,maxResult.CombinedScores
from
(
SELECT
u.ID
,
max(
dbo.JaroWinkler(lower(u.FirstName), lower(c.FirstName))
* dbo.JaroWinkler(LOWER(u.LastName), LOWER(c.LastName))
) AS CombinedScores
FROM dbo.[User] u, dbo.[Contact] c
WHERE u.ContactID IS NULL
GROUP BY u.id
) AS maxResult
INNER JOIN dbo.[User] u
ON maxResult.id = u.id
INNER JOIN dbo.[Contact] c
ON maxResult.CombinedScores =
dbo.JaroWinkler(lower(u.FirstName), lower(c.FirstName))
* dbo.JaroWinkler(LOWER(u.LastName), LOWER(c.LastName))