รู้จักไวยากรณ์ในลำดับของโทเค็นฟัซซี่

ฉันมีเอกสารข้อความที่มีรายการเป็นส่วนใหญ่

แต่ละรายการเป็นกลุ่มของโทเค็นหลายประเภทที่แตกต่างกัน: FirstName, นามสกุล, วันเกิด, หมายเลขโทรศัพท์, เมือง, อาชีพ, ฯลฯ โทเค็นคือกลุ่มของคำ

รายการสามารถวางได้หลายบรรทัด

รายการจากเอกสารจะมีรูปแบบโทเค็นเดียวกัน แต่ไม่จำเป็นต้องเหมือนกันทุกประการ

อาจเป็นโทเค็นบางรายการมากขึ้น / น้อยลงระหว่างไอเท็มรวมถึงภายในไอเท็ม

FirstName LastName BirthDate PhoneNumber
Occupation City
FirstName LastName BirthDate PhoneNumber PhoneNumber
Occupation City
FirstName LastName BirthDate PhoneNumber
Occupation UnrecognizedToken
FirstName LastName PhoneNumber
Occupation City
FirstName LastName BirthDate PhoneNumber
City Occupation

เป้าหมายคือการระบุไวยากรณ์ที่ใช้เช่น

Occupation City

และในท้ายที่สุดระบุรายการทั้งหมดแม้คิดว่าพวกเขาไม่ตรงกัน

เพื่อให้สั้นและอ่านง่ายให้ใช้นามแฝง A, B, C, D, ... แทนเพื่อกำหนดประเภทโทเค็นเหล่านั้น

เช่น

A B C
D F
A B C
D E F
F
A B C
D E E F
A C B
D E F
A B D C
D E F
A B C
D E F G

ที่นี่เราจะเห็นว่ารายการไวยากรณ์คือ

A B C
D E F

เพราะมันเป็นสิ่งที่ตรงกับลำดับที่ดีที่สุด

ไวยากรณ์ (ประเภทโทเค็นและคำสั่งซื้อ) สามารถแตกต่างกันมากจากเอกสารหนึ่งไปยังอีก เช่นเอกสารอื่นอาจมีรายการนั้น

D A
D A
D
D A
B
D A

มีเป้าหมายที่จะคิดออกว่าไวยากรณ์โดยไม่ต้องรู้ก่อนของมัน

จากตอนนี้บรรทัดใหม่ก็ถือว่าเป็นโทเค็นเช่นกัน จากนั้นเอกสารสามารถแสดงเป็นลำดับ 1 โทเค็นของโทเค็น:

ที่นี่ลำดับซ้ำแล้วซ้ำอีกจะเป็นA B C Bเพราะเป็นโทเค็นที่สร้างความขัดแย้งน้อยที่สุด

มาทำให้ซับซ้อนหน่อย โทเค็นแต่ละประเภทไม่มีประเภทที่แน่นอน ในโลกแห่งความเป็นจริงเราจะไม่แน่ใจ 100% บางประเภทของโทเค็น แต่เราให้ความน่าจะเป็นที่จะมีบางประเภทแทน

  A 0.2    A 0.0    A 0.1
  B 0.5    B 0.5    B 0.9     etc.
  C 0.0    C 0.0    C 0.0
  D 0.3    D 0.5    D 0.0

นี่คือกราฟิกนามธรรมของสิ่งที่ฉันต้องการบรรลุ:

วิธีแก้ปัญหาที่ถือว่า A: Convolution ของ patch tokens

โซลูชันนี้ประกอบด้วยการใช้การแปลงด้วยโทเค็นของโทเค็นหลายชุดและใช้วิธีที่สร้างความขัดแย้งน้อยที่สุด

ส่วนที่ยากที่นี่คือการหาแพทช์ที่มีศักยภาพที่จะหมุนไปตามลำดับการสังเกต ความคิดเพียงเล็กน้อยสำหรับสิ่งนี้ แต่ไม่มีอะไรน่าพึงพอใจมาก:

สร้างแบบจำลอง Markov ของการเปลี่ยนระหว่างโทเค็น

ข้อเสียเปรียบ: เนื่องจากโมเดลของ Markov ไม่มีหน่วยความจำเราจะสูญเสียคำสั่งของการเปลี่ยนแปลง เช่นหากลำดับซ้ำA B C B Dเราสูญเสียความจริงที่ว่า A-> B เกิดขึ้นก่อน C-> B

สร้างต้นไม้ต่อท้าย

สิ่งนี้ดูเหมือนจะถูกนำมาใช้อย่างกว้างขวางในชีววิทยาเพื่อวิเคราะห์นิวเคลียส (GTAC) ใน DNA / RNA ข้อเสียเปรียบ: คำต่อท้ายต้นไม้นั้นเหมาะสำหรับการจับคู่โทเค็นที่แน่นอน (เช่นตัวอักษร) เราไม่มีลำดับที่แน่นอนหรือโทเค็นที่แน่นอน

กำลังดุร้าย

ลองชุดค่าผสมทุกขนาด สามารถใช้งานได้จริง แต่จะใช้เวลา (ยาว (ยาว))

คำตอบที่พิจารณาว่า B: สร้างตารางของ Levenshtein ระยะทางของคำต่อท้าย

สัญชาตญาณคืออาจมีระยะทางน้อยที่สุดในท้องถิ่นเมื่อคำนวณระยะทางจากคำต่อท้ายทุกคำต่อท้าย

ฟังก์ชันระยะทางคือระยะทาง Levenshtein แต่เราจะสามารถปรับแต่งได้ในอนาคตเพื่อพิจารณาความน่าจะเป็นที่จะเป็นบางประเภทแทนที่จะมีประเภทคงที่สำหรับแต่ละโทเค็น

เพื่อให้ง่ายในการสาธิตเราจะใช้โทเค็นชนิดคงที่และใช้เลเยอร์ดั้งเดิมเพื่อคำนวณระยะห่างระหว่างโทเค็น

ABCGDEFGH ABCDEFGH ABCDNEFGHเช่นกันเถอะมีลำดับการป้อนข้อมูล

เราคำนวณระยะทางของคำต่อท้ายทุกคำต่อท้าย (ครอบตัดให้มีขนาดเท่ากัน):

for i = 0 to sequence.lengh
  for j = i to sequence.lengh
    # Create the suffixes
    suffixA = sequence.substr(i)
    suffixB = sequence.substr(j)
    # Make the suffixes the same size
    chunkLen = Math.min(suffixA.length, suffixB.length)
    suffixA = suffixA.substr(0, chunkLen)
    suffixB = suffixB.substr(0, chunkLen)
    # Compute the distance
    distance[i][j] = LevenshteinDistance(suffixA, suffixB)

เราได้รับเช่นผลลัพธ์ต่อไปนี้ (สีขาวคือระยะทางเล็ก ๆ สีดำมีขนาดใหญ่):

ตอนนี้เป็นที่ชัดเจนว่าคำต่อท้ายใด ๆ เมื่อเทียบกับตัวเองจะมีระยะห่างเป็นโมฆะ แต่เราไม่ได้สนใจด้วยการจับคู่คำต่อท้าย (หรือบางส่วน) ดังนั้นเราจึงครอบตัดส่วนนั้น

เนื่องจากส่วนต่อท้ายถูกครอบตัดให้มีขนาดเท่ากันการเปรียบเทียบสตริงที่ยาวจะให้ระยะทางที่ใหญ่กว่าการเปรียบเทียบสตริงที่มีขนาดเล็กกว่าเสมอ

เราจำเป็นต้องชดเชยว่าด้วยการลงโทษที่ราบรื่นเริ่มจากด้านขวา (+ P) แล้วค่อย ๆ จางหายไปเป็นเส้นตรงไปทางซ้าย

ฉันยังไม่แน่ใจว่าจะเลือกฟังก์ชั่นการลงโทษที่ดีที่เหมาะสมกับทุกกรณีได้อย่างไร

ที่นี่เราใช้การลงโทษ (+ P = 6) ที่มุมขวาสุดแล้วจางไปทางซ้าย 0

ตอนนี้เราสามารถเห็นได้อย่างชัดเจนว่ามีเส้นทแยงมุม 2 เส้นโผล่ออกมา มี 3 รายการ (รายการ 1, รายการ 2, รายการ 3) ในลำดับนั้น บรรทัดที่ยาวที่สุดแสดงถึงการจับคู่ระหว่าง Item1 กับ Item2 และ Item2 กับ Item3 ยาวที่สุดที่สองแสดงถึงการจับคู่ระหว่าง Item1 กับ Item3

ตอนนี้ฉันไม่แน่ใจเกี่ยวกับวิธีที่ดีที่สุดในการใช้ประโยชน์จากข้อมูลนั้น มันง่ายเหมือนการทำเส้นทแยงมุมสูงสุดหรือไม่?

สมมติว่ามันเป็น

ลองคำนวณค่าเฉลี่ยของเส้นทแยงมุมที่เริ่มจากแต่ละโทเค็น เราสามารถเห็นผลลัพธ์ในภาพต่อไปนี้ (เวกเตอร์ด้านล่างเมทริกซ์):

เห็นได้ชัดว่ามี 3 ท้องถิ่นน้อยที่สุดที่ตรงกับจุดเริ่มต้นของแต่ละรายการ ดูน่าอัศจรรย์!

ตอนนี้เราจะเพิ่มความไม่สมบูรณ์เพิ่มขึ้นในลำดับ: ABCGDEFGH ABCDEFGH TROLL ABCDEFGH

เห็นได้ชัดว่าตอนนี้ค่าเฉลี่ยของเส้นทแยงมุมของเวกเตอร์ของเรานั้นยุ่งเหยิงและเราไม่สามารถใช้ประโยชน์จากมันได้อีกต่อไป ...

ข้อสันนิษฐานของฉันคือสิ่งนี้สามารถแก้ไขได้โดยฟังก์ชันระยะทางที่กำหนดเอง (แทน Levenshtein) ซึ่งการแทรกทั้งบล็อกอาจไม่ถูกลงโทษมากนัก นั่นคือสิ่งที่ฉันไม่แน่ใจ

ข้อสรุป

ไม่มีวิธีแก้ปัญหาที่ใช้วิธีการบิดแบบสำรวจที่เหมาะกับปัญหาของเรา

โซลูชันที่อิงกับ Levenshtein ทางไกลดูมีแนวโน้มโดยเฉพาะอย่างยิ่งเพราะมันเข้ากันได้กับโทเค็นประเภทความน่าจะเป็น แต่ฉันยังไม่แน่ใจเกี่ยวกับวิธีการใช้ประโยชน์จากผลลัพธ์ของมัน

ฉันจะขอบคุณมากถ้าคุณมีประสบการณ์ในสาขาที่เกี่ยวข้องและคำแนะนำที่ดีที่จะให้เราหรือเทคนิคอื่น ๆ ในการสำรวจ ขอบคุณล่วงหน้า.

คุณอาจต้องการที่จะดูที่ซ่อนมาร์คอฟรุ่นหรือStochastic บริบทฟรีไวยากรณ์ พวกเขาทั้งสองสามารถใช้ในการสร้างแบบจำลองไวยากรณ์และอนุมานจากข้อมูล

ยกตัวอย่างเช่นทั้งสองได้ถูกนำมาใช้ในอดีตที่ผ่านมาในการจำลองลำดับพันธุกรรมเช่นนี้และนี้