tutorial cohere text embedder

Co: ที่นี่ตัวแยกประเภทข้อความเทียบกับฟอเรสต์สุ่ม

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

มีหลายวิธีในการสร้างการฝังข้อความ แต่วิธีที่พบบ่อยที่สุดคือการใช้โครงข่ายประสาทเทียม โครงข่ายประสาทเทียมเป็นอัลกอริธึมการเรียนรู้ของเครื่องที่เก่งมากในการเรียนรู้ความสัมพันธ์ที่ซับซ้อน อินพุตของโครงข่ายประสาทเทียมเป็นเวกเตอร์ และเอาต์พุตเป็นเวกเตอร์ที่มีขนาดเท่ากัน โครงข่ายประสาทเทียมเรียนรู้ที่จะแมปเวกเตอร์อินพุตกับเวกเตอร์เอาต์พุตในลักษณะที่จับความสัมพันธ์ระหว่างอินพุตและเอาต์พุต

ในการสร้างการฝังข้อความ โครงข่ายประสาทเทียมจะได้รับการฝึกบนคลังข้อความขนาดใหญ่เป็นครั้งแรก ข้อมูลการฝึกอบรมคือชุดของประโยค และแต่ละประโยคจะแสดงเป็นเวกเตอร์ เวกเตอร์ถูกสร้างขึ้นโดยการนำคำว่าเวกเตอร์ของคำในประโยคมารวมเข้าด้วยกัน จากนั้นโครงข่ายประสาทเทียมจะได้รับการฝึกให้แมปเวกเตอร์ประโยคให้เป็นขนาดเวกเตอร์คงที่

เมื่อโครงข่ายประสาทเทียมได้รับการฝึกฝนแล้ว ก็จะสามารถใช้เพื่อสร้างการฝังข้อความสำหรับข้อความชิ้นใหม่ได้ ข้อความใหม่จะแสดงเป็นเวกเตอร์ก่อน จากนั้นโครงข่ายประสาทเทียมจะถูกนำมาใช้เพื่อแมปเวกเตอร์กับขนาดเวกเตอร์คงที่ ผลลัพธ์ที่ได้คือการฝังข้อความที่จับความหมายของข้อความ

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

มีหลายวิธีในการสร้างการฝังข้อความ และการเลือกวิธีจะขึ้นอยู่กับแอปพลิเคชัน อย่างไรก็ตาม โครงข่ายประสาทเทียมเป็นวิธีที่มีประสิทธิภาพและใช้กันอย่างแพร่หลายในการสร้างการฝังข้อความ

บริษัท:นี่

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

เราจะเปรียบเทียบ Random Forest กับ Co:here Classifier ดังนั้นเราจึงต้องเตรียมข้อมูลในสองวิธี สำหรับ Random Forest เราจะใช้ Co:here Embedder เราจะเน้นไปที่สิ่งนี้ในบทช่วยสอนนี้ ตัวแยกประเภท 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 ตัวอย่าง แต่สำหรับ Random Forest เราสามารถใช้ตัวอย่างได้ 1,000 ตัวอย่าง ด้วยการวนซ้ำ for เราสามารถรับชื่อของแต่ละไฟล์ได้ ฟังก์ชั่นทั้งหมดมีลักษณะดังนี้:

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

def load_examples ( no_of_ex ):
    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 ( no_of_ex // len ( folders_name )):
            random_example = np . random . randint ( 0 , len ( files_name ))
            examples_path . append ( files_name [ random_example ])
    return examples_path

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

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

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

 def examples ( no_of_ex ):
    texts = []
    examples_path = load_examples ( no_of_ex )
    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 เราต้องเพิ่มวิธีหนึ่ง - เพื่อฝังตัวอย่าง

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

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

รายการ texts ที่จะฝัง

truncate หากข้อความยาวกว่าโทเค็นที่มีอยู่ ซึ่งเป็นส่วนหนึ่งของข้อความที่ควรใช้ LEFT , RIGHT หรือ NONE

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

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

 def embed ( self , no_of_ex ):
        # as a good developer we should split the dataset. 
        data = pd . DataFrame ( examples ( no_of_ex ))
        self . X_train , self . X_test , self . y_train , self . y_test = train_test_split (
            list ( data [ 0 ]), list ( data [ 1 ]), test_size = 0.2 , random_state = 0 )
        # in the next two lines we create a numeric form of X_train data
        self . X_train_embeded = self . co . embed ( texts = X_train ,
                                              model = "large" ,
                                              truncate = "LEFT" ). embeddings
        self . X_test_embeded = self . co . embed ( texts = X_test ,
                                             model = "large" ,
                                             truncate = "LEFT" ). embeddings

X_train_embeded จะเป็นอาร์เรย์ของตัวเลข ซึ่งมีลักษณะดังนี้:

 [ 386, 0.39653537, -0.409076, 0.5956299, -0.06624506, 2.0539167, 0.7133603,...

- แอปพลิเคชันเว็บ - 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 ( "Co:here Text Classifier vs Random Forest" )

api_key = st . text_input ( "API Key:" , type = "password" )

cohere = CoHere ( api_key )

cohere . list_of_examples ( 50 )  # number of examples for Cohere classifier
                             # showed in the previous tutorial 
cohere . embed ( 1000 )           # number of examples for random forest

# initialization of random forest with sklearn library
forest = RandomForestClassifier ( max_depth = 10 , random_state = 0 ) 

col1 , col2 = st . columns ( 2 )

if col1 . button ( "Classify" ):
    # training process of random forest, to do it we use embedded text.
    forest . fit ( cohere . X_train_embeded , cohere . y_train )
    # prediction process of random forest
    predict = forest . predict_proba ( np . array ( cohere . X_test_embeded [ 0 ]). reshape ( 1 , - 1 ))[ 0 ] 
    here = cohere . classify ([ cohere . X_test [ 0 ]])[ 0 ] # prediction process of cohere classifier
    col2 . success ( f"Correct prediction: { cohere . y_test [ 0 ] } " ) # display original label

    col1 , col2 = st . columns ( 2 )
    col1 . header ( "Co:here classify" ) # predictions for cohere
    for con in here . confidence :
        col1 . write ( f" { con . label } : { np . round ( con . confidence * 100 , 2 ) } %" )
        col1 . progress ( con . confidence )

    col2 . header ( "Random Forest" ) # predictions for random forest
    for con , pred in zip ( here . confidence , predict ):
        col2 . write ( f" { con . label } : { np . round ( pred * 100 , 2 ) } %" )
        col2 . progress ( pred )

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

 streamlit run name_of_your_file . py

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

บทสรุป

การฝังข้อความเป็นเครื่องมืออันทรงพลังที่สามารถใช้เพื่อปรับปรุงประสิทธิภาพของอัลกอริธึมการเรียนรู้ของเครื่อง โครงข่ายประสาทเทียมเป็นวิธีที่ใช้กันอย่างแพร่หลายและมีประสิทธิภาพในการสร้างการฝังข้อความ การฝังข้อความสามารถใช้สำหรับงานต่างๆ เช่น การจัดประเภทข้อความ ความคล้ายคลึงกันของข้อความ และการจัดกลุ่มข้อความ

ในบทช่วยสอนนี้ เราจะเปรียบเทียบ Random Forest กับ Co:here Classifier แต่ความเป็นไปได้ของ Co:here Embedder นั้นยิ่งใหญ่มาก คุณสามารถสร้างสิ่งต่าง ๆ มากมายด้วยมัน

คอยติดตามบทเรียนในอนาคต! ที่เก็บโค้ดนี้สามารถตรวจสอบได้ที่นี่

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