tutorial cohere text classifier

ตัวแยกประเภทข้อความส่วนตัวของคุณ - แอปพลิเคชัน Co:here

การประมวลผลภาษาธรรมชาติเป็นสาขาวิชาวิทยาการคอมพิวเตอร์และภาษาศาสตร์ที่เกี่ยวข้องกับปฏิสัมพันธ์ระหว่างคอมพิวเตอร์กับภาษาของมนุษย์ (ธรรมชาติ) ในรูปแบบที่ง่ายที่สุด NLP คือการพัฒนาอัลกอริธึมที่สามารถเข้าใจและสร้างภาษามนุษย์ได้โดยอัตโนมัติ เป้าหมายระยะยาวของ NLP คือการสร้างแบบจำลองทางคอมพิวเตอร์ของภาษามนุษย์ที่สามารถนำมาใช้ในการทำงานต่างๆ ได้อย่างหลากหลาย งานเหล่านี้รวมถึงการแปลอัตโนมัติ การสรุป การตอบคำถาม การดึงข้อมูล และอื่นๆ อีกมากมาย การวิจัย NLP เป็นการวิจัยแบบสหวิทยาการระดับสูง โดยเกี่ยวข้องกับนักวิจัยจากสาขาต่างๆ เช่น ภาษาศาสตร์ วิทยาศาสตร์เกี่ยวกับความรู้ความเข้าใจ ปัญญาประดิษฐ์ และวิทยาศาสตร์คอมพิวเตอร์

มีวิธีการต่างๆ มากมายที่ใช้ในการประมวลผลภาษาธรรมชาติ รวมถึงวิธีตามกฎ วิธีทางสถิติ และวิธีการคำนวณทางประสาท วิธีการตามกฎมักจะขึ้นอยู่กับกฎที่สร้างขึ้นด้วยมือซึ่งเขียนโดยผู้เชี่ยวชาญ NLP วิธีการเหล่านี้มีประสิทธิภาพมากสำหรับงานเฉพาะเจาะจง แต่มักมีขอบเขตจำกัดและต้องใช้ความพยายามอย่างมากในการรักษา วิธีการทางสถิติขึ้นอยู่กับการใช้ข้อมูลจำนวนมากเพื่อฝึกแบบจำลองการคำนวณ โมเดลเหล่านี้สามารถใช้เพื่อทำงาน NLP ต่างๆ ได้โดยอัตโนมัติ โครงข่ายประสาทเทียมเป็นอัลกอริทึมการเรียนรู้ของเครื่องประเภทหนึ่งที่เหมาะกับงาน NLP เป็นพิเศษ โครงข่ายประสาทเทียมถูกนำมาใช้เพื่อสร้างแบบจำลองที่ล้ำสมัยสำหรับงานต่างๆ เช่น การแปลด้วยเครื่องและการจัดหมวดหมู่

บริษัท:นี่

Co:here คือโครงข่ายประสาทเทียมอันทรงพลัง ซึ่งสามารถสร้าง ฝัง และจัดประเภทข้อความได้ ในบทช่วยสอนนี้ เราจะใช้ Co:ที่นี่ เพื่อจัดประเภทคำอธิบาย หากต้องการใช้ Co:here คุณต้องสร้างบัญชีบน Co:here และรับคีย์ API

เราจะเขียนโปรแกรมด้วย Python ดังนั้นเราจึงจำเป็นต้องติดตั้งไลบรารี cohere ด้วย pip

 pip install cohere

ก่อนอื่นเราต้องนำ cohere.Client ไปใช้งาน ในอาร์กิวเมนต์ของ Client ควรเป็นคีย์ API ที่คุณสร้างไว้ก่อนหน้านี้และเวอร์ชัน 2021-11-08 ฉันจะสร้างคลาส CoHere ซึ่งจะมีประโยชน์ในขั้นตอนต่อไป

 class CoHere :
    def __init__ ( self , api_key ):
        self . co = cohere . Client ( f' { api_key } ' , '2021-11-08' )
        self . examples = []

- ชุดข้อมูล

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

ชุดข้อมูลที่ดาวน์โหลดมี 10 โฟลเดอร์ในแต่ละโฟลเดอร์เป็น 100 files.txt พร้อมคำอธิบาย ชื่อของไฟล์เป็นป้ายกำกับคำอธิบาย เช่น sport_3.txt

ในฟิลด์นี้ งานคือการอ่านคำอธิบายและป้ายกำกับจากไฟล์ และสร้างข้อมูลซึ่งมีคำอธิบายและป้ายกำกับเป็นตัวอย่างหนึ่งของข้อมูล ตัวแยกประเภท Cohere ต้องใช้ตัวอย่าง ซึ่งแต่ละตัวอย่างควรได้รับการออกแบบเป็นรายการ [description, label]

กำลังโหลดเส้นทางของตัวอย่าง

ในตอนแรก เราต้องโหลดข้อมูลทั้งหมดก่อนจึงจะทำเช่นนั้นได้ เราสร้างฟังก์ชัน load_examples ในฟังก์ชันนี้เราจะใช้ไลบรารีภายนอกสามไลบรารี:

os.path เพื่อเข้าไปในโฟลเดอร์ที่มีข้อมูล รหัสถูกดำเนินการในเส้นทางโดยที่ file.py ของหลาม นี่คือไลบรารีภายใน ดังนั้นเราจึงไม่จำเป็นต้องติดตั้ง

numpy นี้มีประโยชน์ในการทำงานกับอาร์เรย์ ในบทช่วยสอนนี้ เราจะใช้มันเพื่อสร้างตัวเลขสุ่ม คุณต้องติดตั้งไลบรารีนี้โดย pip pip install numpy

glob ช่วยให้เราอ่านไฟล์และชื่อโฟลเดอร์ทั้งหมด นี่คือไลบรารีภายนอก ดังนั้นจึงจำเป็นต้องมีการติดตั้ง - pip install glob

ชุดข้อมูลที่ดาวน์โหลดควรถูกแตกออกมาในโฟลเดอร์ data โดย os.path.join เราจะได้รับเส้นทางสากลของโฟลเดอร์

 folders_path = os . path . join ( 'data' , '*' )

ใน windows การส่งคืนจะเท่ากับ data*

จากนั้นเราสามารถใช้วิธี glob เพื่อรับชื่อโฟลเดอร์ทั้งหมดได้

 folders_name = glob ( folders_path )

folders_name คือรายการซึ่งมีเส้นทางหน้าต่างของโฟลเดอร์ ในบทช่วยสอนนี้ ชื่อป้ายกำกับเหล่านี้คือ

[ 'data \ business' , 'data \ entertainment' , 'data \ food' , 'data \ graphics' , 'data \ historical' , 'data \ medical' , 'data \ politics' , 'data \ space' , 'data \ sport' , 'data \ technologie' ]

ขนาดของชุดข้อมูลการฝึกอบรม Co:here ต้องไม่เกิน 50 ตัวอย่าง และแต่ละคลาสต้องมีอย่างน้อย 5 ตัวอย่าง ด้วยการวนซ้ำ for เราสามารถรับชื่อของแต่ละไฟล์ได้ ฟังก์ชั่นทั้งหมดมีลักษณะดังนี้:

 import os . path
from glob import glob
import numpy as np

def load_examples ():
    examples_path = []

    folders_path = os . path . join ( 'data' , '*' )
    folders_name = glob ( folders_path )

    for folder in folders_name :
        files_path = os . path . join ( folder , '*' )
        files_name = glob ( files_path )
        for i in range ( 50 // len ( folders_name )):
            random_example = np . random . randint ( 0 , len ( files_name ))
            examples_path . append ( files_name [ random_example ])
    return examples_path

วงสุดท้ายคือการสุ่ม 5 เส้นทางของแต่ละป้ายกำกับและผนวกเข้ากับรายการใหม่ examples_path

โหลดคำอธิบาย

ตอนนี้เราต้องสร้างชุดฝึกซ้อม เราจะโหลดตัวอย่างด้วย load_examples() ในแต่ละพาธคือชื่อของคลาส เราจะใช้มันเพื่อสร้างตัวอย่าง คำอธิบายจำเป็นต้องอ่านจากไฟล์ ความยาวต้องไม่ยาว ดังนั้นในการกวดวิชานี้ ความยาวจะเท่ากับ 100 ในรายการ texts จะถูกผนวกรายการ [descroption, class_name] ดังนั้นผลตอบแทนจึงเป็นรายการนั้น

 def examples ():
    texts = []
    examples_path = load_examples ()
    for path in examples_path :
        class_name = path . split ( os . sep )[ 1 ]
        with open ( path , 'r' , encoding = "utf8" ) as file :
            text = file . read ()[: 100 ]
            texts . append ([ text , class_name ])
    return texts 

Co:here ตัวแยกประเภท

เรากลับไปที่ชั้นเรียน CoHere เราต้องเพิ่มสองวิธี - เพื่อโหลดตัวอย่างและจำแนกอินพุต

วิธีแรกนั้นเรียบง่าย โดยจะต้องสร้างรายการตัวอย่าง co:here ด้วยเมธอด cohere เพิ่มเติม - cohere.classify.Example

 def list_of_examples ( self ):
        for e in examples ():
            self . examples . append ( Example ( text = e [ 0 ], label = e [ 1 ]))

วิธีที่สองคือการจำแนกวิธีการจาก cohere วิธีการนี้มีอาร์กิวเมนต์เซิร์ฟเวอร์ เช่น:

ขนาด model ของโมเดล

inputs รายการข้อมูลที่จะจำแนก

รายการ examples ชุดการฝึกพร้อมตัวอย่าง

ทั้งหมดนี้คุณสามารถหาได้ที่นี่

ในบทช่วยสอนนี้ วิธี cohere จะถูกนำไปใช้เป็นวิธีการของคลาส CoHere ของเรา อาร์กิวเมนต์ของวิธีนี้คือรายการคำอธิบายที่ต้องทำนาย

 def classify ( self , inputs ):
        return self . co . classify (
            model = 'medium' ,
            inputs = inputs ,
            examples = self . examples
        ). classifications

ผลลัพธ์ที่ได้คือ input prediction อินพุต และรายการ confidence Confidence คือรายการความน่าจะเป็นของแต่ละชั้นเรียน

 cohere . Classification {
        input :
        prediction : 
        confidence : []
}

คลาส CoHere

 import cohere
from loadExamples import examples
from cohere . classify import Example

class CoHere :
    def __init__ ( self , api_key ):
        self . co = cohere . Client ( f' { api_key } ' , '2021-11-08' )
        self . examples = []

    def list_of_examples ( self ):
        for e in examples ():
            self . examples . append ( Example ( text = e [ 0 ], label = e [ 1 ]))

    def classify ( self , inputs ):
        return self . co . classify (
            model = 'medium' ,
            taskDescription = '' ,
            outputIndicator = '' ,
            inputs = inputs ,
            examples = self . examples
        ). classifications 

- แอปพลิเคชันเว็บ - Streamlit

ในการสร้างแอปพลิเคชันซึ่งจะเป็นช่องป้อนข้อความและการแสดงโอกาส เราจะใช้ Stramlit นี่เป็นห้องสมุดที่ง่ายและมีประโยชน์มาก

การติดตั้ง

 pip install streamlit

เราจะต้องมีการป้อนข้อความสองรายการสำหรับ co:here API และสำหรับข้อความที่จะคาดเดา

ในเอกสารของ streamlit เราสามารถค้นหาวิธีการต่างๆ ได้:

st.header() เพื่อสร้างส่วนหัวในแอปของเรา

st.test_input() เพื่อส่งคำขอข้อความ

st.button() เพื่อสร้างปุ่ม

st.write() เพื่อแสดงผลลัพธ์ของ cohere model

st.progress() เพื่อแสดงแถบความคืบหน้า

st.column() เพื่อแยกแอป

 st . header ( "Your personal text classifier - Co:here application" )

api_key = st . text_input ( "API Key:" , type = "password" )        #text box for API key 

description = [ st . text_input ( "Description:" )]               #text box for text to predict

cohere = CoHere ( api_key )                                    #initialization CoHere
cohere . list_of_examples ()                                   #loading training set 

if st . button ( "Classify" ):   
    here = cohere . classify ( description )[ 0 ]                  #prediction 
    col1 , col2 = st . columns ( 2 )
    for no , con in enumerate ( here . confidence ):              #display likelihood for each label
        if no % 2 == 0 :                                     # in two columns
            col1 . write ( f" { con . label } : { np . round ( con . confidence * 100 , 2 ) } %" )
            col1 . progress ( con . confidence )
        else :
            col2 . write ( f" { con . label } : { np . round ( con . confidence * 100 , 2 ) } %" )
            col2 . progress ( con . confidence )

หากต้องการรันคำสั่งให้ใช้แอป streamlit

 streamlit run name_of_your_file . py

แอพที่สร้างขึ้นมีลักษณะเช่นนี้

บทสรุป

โมเดล Co:here ไม่เพียงแต่ใช้เพื่อสร้างข้อความเท่านั้น แต่ยังใช้สำหรับการจัดหมวดหมู่อีกด้วย ในบทช่วยสอนนี้ เราสามารถจัดประเภทข้อความสั้นด้วยชุดข้อมูลขนาดเล็กได้ มี 50 ตัวอย่างสำหรับ 10 ชั้นเรียน ซึ่งเพียงพอแล้วที่จะรักษาความน่าจะเป็นของการคาดการณ์ไว้ในระดับสูง ชุดข้อมูลขนาดใหญ่ในบางสถานการณ์อาจสร้างได้ยาก ดังนั้นโมเดล Co:here จึงเป็นโซลูชันที่ยอดเยี่ยมสำหรับมัน

คอยติดตามบทเรียนในอนาคต!

ขอบคุณ! - Adrian Banachowicz นักศึกษาฝึกงาน Data Science ใน New Native