Method and system for performing instruction tuning by using heterogeneous languages

Abstract

A method and a system for performing instruction tuning of a language model by using heterogeneous languages according to an embodiment of the present invention can improve zero-shot performance and generalization performance of a language model by performing instruction tuning by using different heterogeneous languages.

Description

Method and system for performing instruction tuning using heterogeneous languages

[0001] The present invention relates to a method and system for performing instruction tuning using heterogeneous languages. More specifically, the present invention relates to a method and system for performing instruction tuning using heterogeneous languages, which can improve the performance of instruction tuning for different heterogeneous languages.

[0002] With the recent emergence of pre-trained language models (Large Language Pretraining models, LLMs) on large-scale general domain data, various tasks previously handled manually are being replaced by artificial intelligence-based ones.

[0003] As the development of ultra-large language models such as Chat GPT, Google's Gemini, Naver's HyperClova, Kakao Brain's KoGPT, and LG's EXAONE increases, various methods to increase the zero-shot performance of ultra-large language models are being studied.

[0004] In particular, research on instruction tuning, a technique for improving the zero-shot performance of extremely large language models, is actively underway. Instruction tuning, a learning method first announced in Google's paper "FLAN (Finetuned Language Models are Zero-Shot Learners), utilizes instruction tuning datasets to fine-tune large language models (LLMs) and thereby improve their zero-shot performance.

[0005] Instruction tuning is a technique in which a large language model learns multiple tasks along with instructions (descriptions about the tasks), and when given instructions for a new task, it understands the task with only the instructions without separate training.

[0006] However, instruction tuning has the problem that it takes a lot of time and money to build resources because it requires various task data and various instructions to be built along with it.

[0007] An embodiment of the present invention provides a method and system for performing instruction tuning using a heterogeneous language to reduce the cost and time required for building resources for instruction tuning.

[0008] In addition, an embodiment of the present invention provides a method and system for performing instruction tuning using heterogeneous languages ​​to increase the zero-shot performance of a very large language model by using instruction tuning using heterogeneous languages.

[0009] However, the technical problems to be solved by the present invention and embodiments of the present invention are not limited to the technical problems described above, and other technical problems may exist.

[0010] A method for performing instruction tuning using heterogeneous languages ​​according to an embodiment of the present invention is a method for performing instruction tuning of a large language model (LLM) using heterogeneous languages ​​in a computing system including a memory and a processor, the method comprising the steps of: setting a first instruction tuning dataset including at least one first task formed in a first language using metadata; setting a second instruction tuning dataset including at least one second task formed in a second language; generating cross-language instructions; and performing instruction tuning on the first instruction tuning dataset and the second instruction tuning dataset using the cross-language instructions, wherein the step of generating the cross-language instructions includes the step of generating at least one first instruction written in the first language, and the step of generating at least one second instruction written in the second language, and wherein the step of performing the instruction tuning includes the step of using the first instruction to tune the first instruction. A method comprising: performing instruction tuning on a second instruction tuning dataset, and performing instruction tuning on the first instruction tuning dataset using the second instruction, wherein the first instruction and the second instruction are set to have the same format.

[0011] In another aspect, the step of setting the first instruction tuning dataset includes the step of generating N or more preset first tasks, where N is a natural number greater than or equal to 1.

[0012] In another aspect, the step of generating the first instruction includes the step of generating 3N first instructions and applying three instructions per task.

[0013] In another aspect, the step of setting the first instruction tuning dataset includes the step of generating 34 NLU (Natural Language Understanding) tasks and 17 NLG (Natural Languagae Generation) tasks based on data collected from one or more of AIHub1, KorPora2, GIthub, Huggingface, KLUE3, Korquad4, ETRI5, Modui corpus, and KoBest.

[0014] In another aspect, the above language model uses a multi-lingual model.

[0015] Meanwhile, a method for performing instruction tuning using heterogeneous languages ​​according to an embodiment of the present invention comprises the steps of: setting a first instruction tuning dataset including at least one first task formed in a first language using metadata; setting a second instruction tuning dataset including at least one second task formed in a second language; generating cross-language instructions; and applying the cross-language instructions to the first instruction tuning dataset and the second instruction tuning dataset to perform inference on data input to the language model; wherein the step of generating the cross-language instructions comprises the steps of: generating at least one first instruction written in the first language; and generating at least one second instruction written in the second language; and wherein the step of performing inference comprises the steps of: applying the first instruction to the second instruction tuning dataset and applying the second instruction to the first instruction tuning dataset to perform inference; The first instruction and the second instruction are set to have the same format.

[0016] Meanwhile, a method for performing instruction tuning using heterogeneous languages ​​according to an embodiment of the present invention comprises the steps of: setting a first instruction tuning dataset including at least one first task formed in a first language using metadata; setting a second instruction tuning dataset including at least one second task formed in a second language; generating cross-language instructions; performing instruction tuning on the first instruction tuning dataset and the second instruction tuning dataset using the cross-language instructions; and applying the cross-language instructions to the first instruction tuning dataset and the second instruction tuning dataset to perform inference on data input to the language model, wherein the step of generating the cross-language instructions comprises the step of generating at least one first instruction written in the first language, and the step of generating at least one second instruction written in the second language, and wherein the step of performing instruction tuning comprises: The method comprises a step of performing instruction tuning on the second instruction tuning dataset using an instruction, and performing instruction tuning on the first instruction tuning dataset using the second instruction, wherein the step of performing inference comprises a step of performing inference by applying the first instruction to the second instruction tuning dataset and applying the second instruction to the first instruction tuning dataset, wherein the first instruction and the second instruction are set to have the same format.

[0017] Meanwhile, a system for performing instruction tuning using a heterogeneous language according to an embodiment of the present invention includes at least one memory, and at least one processor for performing instruction tuning of a language model using a heterogeneous language by reading at least one application stored in the memory, wherein the processor sets a first instruction tuning dataset including at least one first task formed in a first language using metadata, sets a second instruction tuning dataset including at least one second task formed in a second language, generates cross-language instructions including at least one first instruction written in the first language and at least one second instruction written in the second language, performs instruction tuning on the first instruction tuning dataset and the second instruction tuning dataset using the cross-language instructions, and performs inference on data input to the language model by applying the cross-language instructions to the first instruction tuning dataset and the second instruction tuning dataset. Including, performing instruction tuning on the second instruction tuning dataset using the first instruction, performing instruction tuning on the first instruction tuning dataset using the second instruction, applying the first instruction to the second instruction tuning dataset, and performing inference by applying the second instruction to the first instruction tuning dataset, wherein the first instruction and the second instruction are set to have the same format.

[0018] Meanwhile, a computing device according to an embodiment of the present invention includes at least one memory, and at least one processor for performing instruction tuning of a language model using a heterogeneous language by reading out at least one application stored in the memory, and instructions of the processor include instructions for performing a step of setting a first instruction tuning dataset including at least one first task formed in a first language using metadata, a step of setting a second instruction tuning dataset including at least one second task formed in a second language, a step of generating cross-language instructions, a step of performing instruction tuning on the first instruction tuning dataset and the second instruction tuning dataset using the cross-language instructions, and a step of performing inference on data input to the language model by applying the cross-language instructions to the first instruction tuning dataset and the second instruction tuning dataset, wherein the step of generating the cross-language instructions includes a step of generating one or more first instructions written in the first language, and a step of performing inference on data input to the language model. A method comprising: generating one or more second instructions written in a language; wherein the step of performing instruction tuning comprises performing instruction tuning on the second instruction tuning dataset using the first instructions; and performing instruction tuning on the first instruction tuning dataset using the second instructions; wherein the step of performing inference comprises performing inference by applying the first instructions to the second instruction tuning dataset and applying the second instructions to the first instruction tuning dataset; wherein the first instructions and the second instructions are set to have the same format.

[0019] The method and system for performing instruction tuning using a heterogeneous language according to an embodiment of the present invention can reduce the cost and time required for building resources for instruction tuning.

[0020] In addition, the method and system for performing instruction tuning using heterogeneous languages ​​according to an embodiment of the present invention can increase the zero-shot performance of a very large language model by using instruction tuning using heterogeneous languages.

[0021] However, the effects that can be obtained from the present invention are not limited to the effects mentioned above, and other effects that are not mentioned can be clearly understood from the description below.

[0022] FIG. 1 illustrates an example of a block diagram of a computing system that implements instruction tuning of a language model using heterogeneous languages ​​according to an embodiment of the present invention.

[0023] FIG. 2 illustrates an example block diagram of a computing device that implements instruction tuning of a language model using heterogeneous languages ​​according to an embodiment of the present invention.

[0024] FIG. 3 illustrates an example block diagram of another aspect of a computing device that implements instruction tuning of a language model using heterogeneous languages ​​according to an embodiment of the present invention.

[0025] FIG. 4 is an exemplary block diagram illustrating an instruction tuning system for a language model using heterogeneous languages ​​according to an embodiment of the present invention.

[0026] FIG. 5 is an example diagram of a Korean instruction tuning dataset according to an embodiment of the present invention.

[0027] Figure 6 is an example diagram of tasks and instructions according to an embodiment of the present invention.

[0028] FIG. 7 is an example diagram of an English instruction tuning dataset according to an embodiment of the present invention.

[0029] Figure 8 is an example diagram of cross-language instructions according to an embodiment of the present invention.

[0030] FIG. 9 is an example diagram of a language model that performs instruction tuning using a heterogeneous language according to an embodiment of the present invention.

[0031] Figure 10 is a table showing the performance results of a language model according to an embodiment of the present invention.

[0032] Figure 11 is a performance graph of a language model according to an embodiment of the present invention.

[0033] Figures 12 to 14 are flowcharts for explaining a method for tuning instructions of a language model using heterogeneous languages ​​according to an embodiment of the present invention.

[0034] The present invention is capable of various modifications and embodiments. Therefore, specific embodiments are illustrated in the drawings and described in detail in the detailed description. The effects and features of the present invention, as well as the methods for achieving them, will become clear with reference to the embodiments described in detail below together with the drawings. However, the present invention is not limited to the embodiments disclosed below and can be implemented in various forms. In the following embodiments, terms such as first, second, etc. are not used in a limiting sense but are used for the purpose of distinguishing one component from another. Furthermore, the singular expression includes plural expressions unless the context clearly indicates otherwise. Furthermore, terms such as "include" or "have" indicate the presence of a feature or component described in the specification, and do not preemptively exclude the possibility that one or more other features or components may be added. Furthermore, in the drawings, the sizes of components may be exaggerated or reduced for convenience of explanation. For example, the size and thickness of each component shown in the drawings are arbitrarily shown for convenience of explanation, and thus the present invention is not necessarily limited to what is shown.

[0035] Hereinafter, embodiments of the present invention will be described in detail with reference to the attached drawings. When describing with reference to the drawings, identical or corresponding components are given the same reference numerals and redundant descriptions thereof will be omitted.

[0036] Below, an exemplary system for implementing instruction tuning of a language model (Large Language Pretraining model, LLM) using different heterogeneous languages ​​is described in detail with reference to the attached drawings.

[0037] FIG. 1 illustrates an example of a block diagram of a computing system that implements instruction tuning of a language model using heterogeneous languages ​​according to an embodiment of the present invention.

[0038] Referring to FIG. 1, a computing system (1000) for implementing instruction tuning of a language model using a heterogeneous language of the present invention includes a user computing device (110), a server computing system (130), and a training computing system (150), and the devices are capable of communicating via a network (170).

[0039] The method for tuning instructions of a language model using a heterogeneous language according to an embodiment of the present invention may be implemented and provided locally by a user computing device (110), may be implemented and provided in the form of a web service by a server computing system (130) communicating with the user computing device (110), or may be implemented and provided by the user computing device (110) and the server computing system (130) in conjunction with each other.

[0040] At this time, in the embodiment, the user computing device (110) and / or the server computing system (130) can train the language model (120 and / or 140, machine learning model) through interaction with the training computing system (150) communicatively connected via a network (170). The training computing system (150) may be separate from the server computing system (130) or may be part of the server computing system (130).

[0041] And at this time, the artificial intelligence model (in the embodiment, a language model, etc.) can be trained directly locally by the user computing device (110), the server computing system (130) and the user computing device (110) can learn while interacting with each other through a network (170), and a separate training computing system (150) can train using various training techniques and learning techniques. And the artificial intelligence model trained by the training computing system (150) can be implemented in a way that it is provided / updated by transmitting it to the user computing device (110) and / or the server computing system (130) through the network (170).

[0042] In an embodiment, the training computing system (150) may be part of a server computing system (130) or part of a user computing device (110).

[0043] The user computing device (110) may include any type of computing device, such as a smart phone, a mobile phone, a digital broadcasting device, a personal digital assistant (PDA), a portable multimedia player (PMP), a desktop, a wearable device, an embedded computing device, and / or a tablet PC.

[0044] Such a user computing device (110) includes at least one processor (111) and memory (112). Here, the processor (111) may be composed of at least one or a plurality of electrically connected processors among a central processing unit (CPU), a graphics processing unit (GPU), application specific integrated circuits (ASICs), digital signal processors (DSPs), digital signal processing devices (DSPDs), programmable logic devices (PLDs), field programmable gate arrays (FPGAs), controllers, micro-controllers, microprocessors, and / or other electrical units for performing functions.

[0045] The memory (112) may include one or more non-transitory / transitory computer-readable storage media, such as RAM, ROM, EEPROM, EPROM, flash memory devices, magnetic disks, and combinations thereof, and may include web storage of a server that performs a memory storage function on the Internet. The memory (112) may store data (113) and commands (114) necessary for the at least one processor (111) to perform functional operations, such as training an artificial intelligence model or executing anomaly detection using an artificial intelligence model.

[0046] In an embodiment, the user computing device (110) may store at least one machine learning model (120).

[0047] The machine learning model (120) may be various machine learning models such as multiple neural networks (e.g., deep neural networks) or other types of machine learning models including nonlinear models and / or linear models, and may be composed of a combination thereof.

[0048] At this time, the neural network may include at least one of feed-forward neural networks, recurrent neural networks (e.g., long short-term memory recurrent neural networks), convolutional neural networks, and / or other types of neural networks.

[0049] In an embodiment, a user computing device (110) may receive at least one machine learning model (120) from a server computing system (130) via a network (170), store the model in a memory (112), and then execute the stored machine learning model (120) by a processor (111) to perform outlier detection, etc.

[0050] In an embodiment, the server computing system (130) may include at least one machine learning model (140) and perform operations through the machine learning model (140), and may communicate data related thereto with the user computing device (110) in conjunction with the user computing device (110) to provide a language model that has performed instruction tuning using a heterogeneous language to the user.

[0051] For example, a user computing device (110) may provide a language model that has performed instruction tuning in a manner that allows a server computing system (130) to provide output for a user's input using a machine learning model (140) via the web.

[0052] Additionally, the artificial intelligence model may be implemented in such a way that at least some of the machine learning models (120 and / or 140) are executed on a user computing device (110) and the rest are executed on a server computing system (130).

[0053] In addition, the user computing device (110) may include at least one input component (121) that detects a user's input. For example, the user input component (121) may include a touch sensor (e.g., a touch screen and / or a touch pad, etc.) that detects a touch of a user's input medium (e.g., a finger or a stylus), an image sensor that detects a user's motion input, a microphone, a button, a mouse, and / or a keyboard that detects a user's voice input, etc. In addition, the user input component (121) may include an interface and an external controller when receiving an input to an external controller (e.g., a mouse and / or a keyboard, etc.) through an interface.

[0054] The server computing system (130) includes at least one processor (131) and memory (132). Here, the processor (131) may be composed of at least one or a plurality of electrically connected processors among a central processing unit (CPU), a graphics processing unit (GPU), application specific integrated circuits (ASICs), digital signal processors (DSPs), digital signal processing devices (DSPDs), programmable logic devices (PLDs), field programmable gate arrays (FPGAs), controllers, micro-controllers, microprocessors, and / or other electrical units for performing functions.

[0055] The memory (132) may include one or more non-transitory / transitory computer-readable storage media, such as RAM, ROM, EEPROM, EPROM, flash memory devices, magnetic disks, etc., and combinations thereof. The memory (132) may store data (133) and instructions (134) necessary for the processor (131) to perform functional operations, such as training an artificial intelligence model or executing outlier detection using an artificial intelligence model.

[0056] In an embodiment, the server computing system (130) may be implemented to include at least one computing device. For example, the server computing system (130) may be implemented to operate multiple computing devices according to a sequential computing architecture, a parallel computing architecture, or a combination thereof. Additionally, the server computing system (130) may include multiple computing devices connected via a network (170).

[0057] Additionally, the server computing system (130) may store at least one machine learning model (140). For example, the server computing system (130) may include a neural network and / or other multi-layer nonlinear model as the machine learning model (140). Exemplary neural networks may include feedforward neural networks, deep neural networks, recurrent neural networks, and convolutional neural networks.

[0058] The training computing system (150) includes at least one processor (151) and memory (152). Here, the processor (151) may be composed of at least one or a plurality of electrically connected processors among a central processing unit (CPU), a graphics processing unit (GPU), application specific integrated circuits (ASICs), digital signal processors (DSPs), digital signal processing devices (DSPDs), programmable logic devices (PLDs), field programmable gate arrays (FPGAs), controllers, micro-controllers, microprocessors, and / or other electrical units for performing functions.

[0059] And the memory (152) may include one or more non-transitory / transitory computer-readable storage media such as RAM, ROM, EEPROM, EPROM, flash memory devices, magnetic disks, etc., and combinations thereof. This memory (152) may store data (153) and instructions (154) necessary for the processor (151) to perform learning of an artificial intelligence model, etc.

[0060] For example, the training computing system (150) may include a model trainer (160) that trains a machine learning model (120 and / or 140) stored in the user computing device (110) and / or server computing system (130) using various training or learning techniques, such as backpropagation of errors (according to the framework illustrated in FIG. 3).

[0061] For example, such a model trainer (160) may perform updates to one or more parameters of a machine learning model (120 and / or 140) in a backpropagation manner based on a defined loss function.

[0062] In some implementations, performing backward propagation of errors may include performing truncated backpropagation through time. The model trainer (160) may perform a number of generalization techniques (e.g., weight reduction, dropout, and / or knowledge distillation) to improve the generalization ability of the trained machine learning model (120 and / or 140).

[0063] In particular, the model trainer (160) can train the machine learning model (120 and / or 140) based on a series of training data (161). Here, the training data (161) can include data in different formats, such as, for example, images, audio samples, and / or text. Examples of image types that can be used can include video frames, LiDAR point clouds, X-ray images, computed tomography scans, hyperspectral images, and / or various other forms of images.

[0064] Such training data (161) may be provided by a user computing device (110) and / or a server computing system (130). When the training computing device trains a machine learning model (120 and / or 140) on specific data of the user computing device (110), the machine learning model (120 and / or 140) may be characterized as a personalized model.

[0065] And the model trainer (160) includes computer logic utilized to provide the desired function.

[0066] Additionally, the model trainer (160) may be implemented as hardware, firmware, and / or software that controls a general-purpose processor. In one implementation, the model trainer (160) includes a program file stored in a storage device, which may be loaded into a memory (152) and executed by one or more processors (151). In another implementation, the model trainer (160) includes one or more sets of computer-executable data (153) and instructions (154) stored in a tangible computer-readable storage medium, such as a RAM hard disk or an optical or magnetic medium.

[0067] The network (170) includes, but is not limited to, a 3rd Generation Partnership Project (3GPP) network, a Long Term Evolution (LTE) network, a World Interoperability for Microwave Access (WIMAX) network, the Internet, a Local Area Network (LAN), a Wireless Local Area Network (Wireless LAN), a Wide Area Network (WAN), a Personal Area Network (PAN), a Bluetooth network, a satellite broadcasting network, an analog broadcasting network, and / or a Digital Multimedia Broadcasting (DMB) network.

[0068] In general, communication over a network (170) may be performed using any type of wired and / or wireless connection, using various communication protocols (e.g., TCP / IP, HTTP, SMTP, and / or FTP), encodings or formats (e.g., HTML and / or XML), and / or protection schemes (e.g., VPN, Secure HTTP, and / or SSL).

[0069] FIG. 2 illustrates an example block diagram of a computing device that implements instruction tuning of a language model using heterogeneous languages ​​according to an embodiment of the present invention.

[0070] As shown in FIG. 2, the computing device (100) included in the user computing device (110), the server computing system (130), and the training computing system (150) includes a plurality of applications (e.g., Application 1 to Application N). Each application may include a machine learning library and one or more machine learning models. For example, the applications may include a language processing application, a text messaging application, an email application, a dictation application, a virtual keyboard application, a browser application, and / or a chat-bot application.

[0071] In an embodiment, the computing device (100) may include a model trainer (160) for training an artificial intelligence model, and may store and operate the trained artificial intelligence model to provide output data according to predetermined input data (e.g., image data, etc.).

[0072] Each application of the computing device (100) may communicate with a number of other components of the computing device (100), such as, for example, at least one sensor, a context manager, a device state component, and / or additional components. Each application may communicate with each device component using an API (e.g., a public API). Additionally, the API used by each application may be specific to that application.

[0073] FIG. 3 illustrates an example block diagram from another aspect of a computing device (100) that implements instruction tuning of a language model using heterogeneous languages ​​according to an embodiment of the present invention.

[0074] Referring to FIG. 3, a computing device (300) includes a plurality of applications (e.g., Application 1 to Application N). Each application may communicate with a central intelligence layer. For example, the applications may include a language processing application, a text messaging application, an email application, a dictation application, a virtual keyboard application, and / or a browser application. Each application may communicate with the central intelligence layer (and the models stored therein) using an API (e.g., a common API across all applications).

[0075] The central intelligence layer may include multiple machine learning models. For example, as illustrated in FIG. 3, at least some of the machine learning models may be provided to each application and managed by the central intelligence layer. In other implementations, two or more applications may share a single machine learning model. For example, in some implementations, the central intelligence layer may provide a single model to all applications. In some implementations, the central intelligence layer may be included within the operating system of the computing device (300) or implemented differently.

[0076] The central intelligence layer may communicate with a central device data layer. The central device data layer may be a centralized data repository for the computing device (300). As illustrated in FIG. 3, the central device data layer may communicate with a number of other components of the computing device (300), such as, for example, one or more sensors, a context manager, a device state component, and / or additional components. In some implementations, the central device data layer may communicate with each device component using an API (e.g., a private API).

[0077] The techniques described herein may refer to servers, databases, software applications, and other computer-based systems, as well as actions taken and information transmitted to or from such systems. It will be appreciated that the inherent flexibility of computer-based systems allows for a wide range of possible configurations, combinations, and division of labor and functionality between and among components. For example, the processes described herein may be implemented using a single device or component, or multiple devices or components operating in combination. Databases and applications may be implemented on a single system or in a distributed system across multiple systems. Distributed components may operate sequentially or in parallel.

[0078] Hereinafter, with reference to FIG. 4, an instruction tuning system for a language model using heterogeneous languages ​​according to an embodiment of the present invention will be described.

[0079] FIG. 4 is an exemplary block diagram illustrating an instruction tuning system for a language model using heterogeneous languages ​​according to an embodiment of the present invention.

[0080] The instruction tuning system (1000) using heterogeneous languages ​​according to an embodiment of the present invention may refer to a language model (Large Language Pretraining model, LLM) that performs instruction tuning using two different languages.

[0081] An instruction tuning system (1000) using a heterogeneous language includes a memory and a processor, at least one application is stored in the memory, and the processor reads the application stored in the memory and performs instruction tuning of a learning model using a heterogeneous language.

[0082] The function for performing instruction tuning using a heterogeneous language can be illustrated using a block diagram as shown in Fig. 4. Referring to Fig. 4, the processor can perform the functions of the instruction tuning dataset generation module (1100), the cross-language instruction generation module (1200), the instruction tuning module (1300), and the inference module (1400) described below.

[0083] The instruction tuning dataset generation module (1100) generates an instruction tuning dataset using data written in each language to perform instruction tuning for different languages. At this time, the instruction tuning dataset generation module (1100) may generate a first instruction tuning dataset for a first language and a second instruction tuning dataset for a second language differently.

[0084] The instruction tuning dataset creation module (1100) creates and secures various tasks using metadata and open sources to create a first instruction tuning dataset. Furthermore, the instruction tuning dataset creation module (1100) sets M preset instructions (templates) for each task (where M is a natural number greater than or equal to 1).

[0085] At this time, M may be set to have a value of 10, but the embodiment of the present invention is not limited thereto.

[0086] Specifically, the instruction tuning dataset creation module (1100) can create and classify datasets including various open sources such as AIHub1, Korpora2, Github, Huggingface, KLUE3, Korquad4, and ETRI5, as well as language understanding and language generation tasks. In addition, the instruction tuning dataset creation module (1100) can organize dataset clusters using heuristic rules.

[0087] For example, the instruction tuning dataset generation module (1100) can generate the first instruction tuning dataset such that the first instruction tuning dataset is classified into a total of 17 task clusters, including 17 NLG (Natural Language Generation) datasets (1110) and 34 NLU (Natural Language Understanding) datasets (1120), as illustrated in FIG. 5.

[0088] That is, Summarizaiton, Closed-Book QA, Paraphasing, Structure-to-Text, Dialogs, Translation, Sentiment, HateSpeech, Extractive QA, Word Sense Disambiguation, Coreference Resolutino, Topic Classification, Natural Language Inference, Intent, Paraphase Identification, Sentence Completion, and Multiple Choice QA shown in Fig. 5 represent 17 task cluster classifications.

[0089] Additionally, Book, Dacon News, Report, Document News, Document Editorial, ETRI QA, Similar Corpus, Com Gen, AIHub Daily Dial, AIHub Emo Dial, AIHub TOD, AIHub Minwon, AIHub Korean Dialog, Twitter, Ko-En Parallel, Ko-En Social, Ko-En Technology represent 17 NLG datasets, NSMC, Naver Shopping, Kobest Sentineg, Sosang Sentiment, AIHub Emo, Apeach, BEEP!, Curse Detection, UnSmile, Kobest BooIQ, AIHub MRC, Book MRC, KLUE MRC, KorQuAD1, News QA, NIA QA, Kobeast WIC, NIKL Coref, Callcenter, Ko Conversation, KLUE TC, KLUE NLI, KorNLI, Sae4k, StyleKQC, Daily Chat, KLUE STS, KorSTS, KorSS, Question Pair, ParaKQC, Kobest COPA, Kobest Hellaswag, and Document QA refer to 34 NLU datasets.

[0090] In this way, the instruction tuning dataset generation module (1100) generates various NLP (Natural Language Processing) tasks to generate the first instruction tuning dataset, and sets M instructions for each task.

[0091] At this time, the instruction tuning data set generation module (1100) generates an instruction by using all or part of the data labels included in the first instruction tuning data set or by adding a new data label to generate an instruction for the first instruction tuning data set.

[0092] Specifically, as illustrated in FIG. 6, a task (1101) included in the first instruction tuning dataset includes a plurality of data labels and values ​​corresponding to the data labels. The instruction tuning dataset generation module (1100) generates an instruction (1150) for the task (1101) by using all or part of the data labels included in the task (1101) or by adding a new data label. At this time, a plurality of instructions (1150) may be generated for the task (1101), and 10 or more instructions (1150) may be generated and set for each task (1101).

[0093] In addition, the instruction tuning dataset generation module (1100) can generate a second instruction tuning dataset written in a second language. The instruction tuning dataset generation module (1100) can generate the second instruction tuning dataset using the P3 data of T0.

[0094] As an example, as illustrated in FIG. 7, the second instruction tuning dataset can be generated to be classified into a total of 12 task clusters, including 11 NLG (Natural Language Generation) datasets (1111) and 51 NLU (Natural Language Understanding) datasets (1121).

[0095] That is, Summarization, Closed-Book QA, Structure-to-Text, Sentiment, Word Sense Disambiguation, Extractive QA, Coreference Resolution, Multiple Choice QA, Paraphrase Identification, Sentence Completion, Natural Language Inference, and Topic Classification shown in Figure 7 correspond to 12 task clusters.

[0096] Additionally, CNN Daily Mail, Gigaword, MutiNews, SamSum, ReCoRD, ROPES, SQuAD(V1), PubMedQA, Winogrande, WSC, ARC, Art, Cbt, CoS-E, Cosmos QA, DREAM, MultiRC, OpenBookQA PiQA, QASC, QuAIL, QuaRel, QuaRTz, RACE, SciQ, Social IQA, Wiki Hop, WiQA, MRPC, PAWS, QQP, COPA, StoryCloze, Hellaswag, ANLI (R1-3), CB, RTE, EsNLI, AG News, DBPedia, TREC, Yahho Answers Topic refers to 51 NLU datasets (1121).

[0097] Additionally, the instruction tuning dataset generation module (1100) can generate instructions by using all or part of the data labels included in the second instruction tuning dataset or by adding a new data label to generate instructions for the second instruction tuning dataset.

[0098] The cross-language instruction generation module (1200) generates cross-language instructions for performing instruction tuning of a language model using heterogeneous languages ​​(first language and second language).

[0099] A cross-language instruction generation module (1200) can increase the effectiveness of instruction tuning using two languages ​​by generating and setting N cross-language instructions (N is a natural number greater than or equal to 1) per task included in a first instruction tuning dataset and a second instruction tuning dataset.

[0100] At this time, N may be set to have a value of 3, but the embodiment of the present invention is not limited thereto.

[0101] Specifically, the cross-language instruction generation module (1200) generates a first instruction written in a first language and a second instruction written in a second language, respectively. At this time, the first and second instructions are configured to have the same format (data label). Furthermore, the first instruction is applied to a second instruction tuning dataset, and the second instruction is applied to the first instruction tuning dataset.

[0102] That is, the dataset and instructions are set so that the language of the instruction tuning dataset and the language of the instructions intersect with each other.

[0103] The cross-language instruction generation module (1200) can generate a first instruction by machine-translating instructions for a second instruction tuning dataset into a first language, and can generate a second instruction by machine-translating instructions for the first instruction tuning dataset into a second language.

[0104] In addition, the cross-language instruction generation module (1200) can generate a cross-language instruction by preferentially selecting a common data label among the basic instruction for the first instruction tuning data set and the data labels included in the second instruction tuning data set.

[0105] In addition, the cross-language instruction generation module (1200) can generate cross-language instructions by setting weights for each data label based on the frequency of use among the basic instructions for the first instruction tuning data set and the data labels included in the second instruction tuning data set, and adding data labels with weights greater than a reference value.

[0106] Additionally, the cross-language instruction generation module (1200) adds, deletes, and modifies the data label of the first instruction and the label of the second instruction to change the format of the first instruction and the format of the second instruction to be identical.

[0107] Below, Figure 8 is an example of a cross-language instruction.

[0108] Table 1 in Fig. 8 shows examples of cross-language instructions for Xsum: Summarization, Table 2 shows examples of cross-language instructions for WSC: Coreference Resolution, and Table 3 shows examples of cross-language instructions for Emotion: Sentiment.

[0109] The P3 Template in Tables 1 to 3 refers to instructions of the second instruction tuning dataset, the Translated Template refers to instructions simply translated into the first language, and the Cross-Lingual Templates refer to cross-language instructions in which the order or position of data labels or the presence or absence of expressions are changed.

[0110] The instruction tuning module (1300) performs instruction tuning on the first instruction tuning dataset and the second instruction tuning dataset using the cross-language instructions generated by the cross-language instruction generation module (1200).

[0111] That is, the language model (LLM) can perform learning using cross-language instructions and a first instruction tuning dataset and a second instruction tuning dataset.

[0112] Additionally, the inference module (1400) can be used to perform inference using cross-language instructions in the inference step, separately from or in addition to the learning step.

[0113] That is, the language model can perform learning using cross-language instructions and the first instruction tuning data set and the second instruction tuning data set, or perform inference on newly input data using cross-language instructions and the first instruction tuning data set and the second instruction tuning data set, or perform learning and inference on new data using cross-language instructions and the first instruction tuning data set and the second instruction tuning data set.

[0114] At this time, a multi-lingual model can be used as the language model for utilizing the first and second languages.

[0115] Hereinafter, with reference to Fig. 9, the language model using cross-language instructions in the learning and inference stages and the performance of each model are described.

[0116] Figure 9 shows an example of a language model that performs training and inference on cross-language instructions.

[0117] In Figure 9, training and evaluation are distinguished by dotted lines, with the upper part of the dotted line indicating training and the lower part indicating evaluation. Furthermore, the solid line in Figure 9 distinguishes monolingual and bilingual cases, with the left side of the line indicating a monolingual case and the right side of the line indicating a bilingual case.

[0118] Also, in Fig. 9, En-mT0 refers to a language model trained using the second instruction tuning dataset described above. En-mT0-CT refers to a language model that performs training on the second instruction tuning dataset using the cross-language instructions described above only during training and performs inference using the original instructions. En-mT0(CI) refers to a model that performs training on the second instruction tuning dataset using the original instructions and performs inference using the cross-language instructions.

[0119] In addition, Ko-mT0 refers to a language model trained using the first instruction tuning dataset described above. Ko-mT0-CT refers to a language model that performs training on the first instruction tuning dataset using the cross-language instructions described above only during training and performs inference using the original instructions. Ko-mT0(CI) refers to a model that performs training on the first instruction tuning dataset using the original instructions and performs inference using the cross-language instructions.

[0120] At this time, the examples described above and below are explained assuming that the first language is Korean and the second language is English, but the embodiments of the present invention are not limited to this.

[0121] To evaluate the zero-shot performance of each model on each task, we conducted evaluations using two separate holdout settings. The first group included four tasks: natural language inference, sentence completion, coreference resolution, and word sense disambiguation. The second group included three tasks: sentiment analysis, summarization, and multiple-choice QA.

[0122] Figure 10 shows the zero-shot performance and language generalization performance scores of each model.

[0123] As shown in Figure 10, performance improvements were also observed when instruction tuning was applied to two different languages. Specifically, tasks such as objective QA, summarization, and sentence completion in Korean assessment showed similar performance between the En-mT0 and Ko-mT0 models. Furthermore, in English assessment, Ko-mT0 showed similar performance to En-mT0 in sentiment analysis and summarization tasks.

[0124] Furthermore, CT and CI models utilizing cross-language instructions showed improved performance in most metrics compared to models utilizing the original instructions. Specifically, in the Korean evaluation, En-mT0-CT and En-mT0(CI) showed significant performance improvements compared to En-mT0. Similarly, in the English evaluation, Ko-mT0-CT and Ko-mT0(CI) showed improved performance compared to Ko-mT0. Therefore, it was confirmed that training and inference of language models using cross-language instructions improved performance compared to tuning instructions using a single language.

[0125] Additionally, Figure 11 is a graph depicting the average task performance for both Korean and English. As shown in Figure 11, the performance of all instruction-tuned models improves as the model size increases. Furthermore, it can be confirmed that models utilizing cross-language instructions (En-mT0-CT, En-mT0-CI, Ko-mT0-CT, Ko-mT0-CI) show greater performance improvement than the standard models (En-mT0, Ko-mT0) across various model sizes.

[0126] Hereinafter, a method for performing instruction tuning of a language model using heterogeneous languages ​​according to an embodiment of the present invention will be described in detail with reference to FIGS. 12 to 14.

[0127] Figures 12 to 14 are flowcharts of a method for performing instruction tuning of a language model using heterogeneous languages ​​according to an embodiment of the present invention.

[0128] Referring to FIG. 12, a method for performing instruction tuning of a language model using heterogeneous languages ​​according to an embodiment of the present invention may include a first language instruction dataset creation step (S100), a second language instruction dataset creation step (S200), a cross-language instruction creation step (S300), and an instruction tuning step (S400).

[0129] In the first language instruction dataset creation step (S100), the instruction tuning system for a language model using heterogeneous languages ​​can create and classify datasets including various open sources such as AIHub1, Korpora2, Github, Huggingface, KLUE3, Korquad4, and ETRI5, as well as language understanding and language generation tasks.

[0130] In addition, in the first language instruction dataset creation step (S100), the instruction tuning system for a language model using heterogeneous languages ​​can form clusters of the dataset using heuristic rules.

[0131] Specifically, in the first language instruction dataset generation step (S100), the instruction tuning system for a language model using a heterogeneous language can generate the first instruction tuning dataset so that the first instruction tuning dataset is classified into a total of 17 task clusters, including 17 NLG (Natural Language Generation) datasets (1110) and 34 NLU (Natural Language Understanding) datasets (1120), as illustrated in FIG. 5.

[0132] In addition, in the first language instruction dataset creation step (S100), the instruction tuning system for a language model using a heterogeneous language can set a basic instruction for the first instruction tuning dataset, and at this time, the basic instruction is set using the same first language as the first instruction tuning dataset.

[0133] In addition, the basic instructions for the first instruction tuning dataset are generated by the instruction tuning system for a language model using a heterogeneous language by using all or part of the data labels included in the first instruction tuning dataset or by adding new data labels.

[0134] In the second language instruction dataset creation step (S200), the instruction tuning system for a language model using a heterogeneous language can create and set a second instruction tuning dataset and basic instructions using P3 data.

[0135] In the cross-language instruction generation step (S300), the instruction tuning system for a language model using heterogeneous languages ​​generates and sets N cross-language instructions (N is a natural number greater than or equal to 1) per task included in the first instruction tuning dataset and the second instruction tuning dataset, thereby increasing the effectiveness of instruction tuning using two languages.

[0136] At this time, N may be set to have a value of 3, but the embodiment of the present invention is not limited thereto.

[0137] Specifically, in the cross-language instruction generation step (S300), the instruction tuning system for a language model using different languages ​​generates a first instruction written in a first language and a second instruction written in a second language, respectively. At this time, the first and second instructions are configured to have the same format (data label). Furthermore, the first instruction is applied to a second instruction tuning dataset, and the second instruction is applied to the first instruction tuning dataset.

[0138] That is, the dataset and instructions are set so that the language of the instruction tuning dataset and the language of the instructions intersect with each other.

[0139] An instruction tuning system for a language model using heterogeneous languages ​​can generate first instructions by machine translating instructions for a second instruction tuning dataset into a first language, and can generate second instructions by machine translating instructions for the first instruction tuning dataset into a second language.

[0140] In addition, the instruction tuning system for a language model using heterogeneous languages ​​can generate cross-language instructions by preferentially selecting data labels commonly included among the basic instructions for the first instruction tuning dataset and the data labels included in the second instruction tuning dataset.

[0141] In addition, the instruction tuning system for a language model using heterogeneous languages ​​can generate cross-language instructions by setting weights for each data label based on the frequency of use among the basic instructions for the first instruction tuning dataset and the data labels included in the second instruction tuning dataset, and adding data labels with weights greater than a reference value.

[0142] In addition, in the cross-language instruction generation step (S300), the instruction tuning system of a language model using a heterogeneous language adds, deletes, and modifies the data label of the first instruction and the label of the second instruction to change the format of the first instruction and the format of the second instruction to be identical.

[0143] In the instruction tuning step (S400), the instruction tuning system for a language model using a heterogeneous language performs learning (tuning) of a language model (LLM, mT0) by applying cross-language instructions to a first instruction tuning dataset and / or a second instruction tuning dataset.

[0144] In addition, referring to FIG. 13, a method for performing instruction tuning of a language model using heterogeneous languages ​​according to an embodiment of the present invention may include a first language instruction dataset creation step (S100), a second language instruction dataset creation step (S200), a cross-language instruction creation step (S300), and an inference step (S500).

[0145] In the inference step (S500), the basic instructions of the first instruction tuning dataset and the second instruction tuning dataset are applied to learn (tune) the language model, and then in the inference step of the learning model for the input data, cross-language instructions are applied to the first instruction tuning dataset and / or the second instruction tuning dataset to perform inference.

[0146] In addition, referring to FIG. 14, a method for performing instruction tuning of a language model using heterogeneous languages ​​according to an embodiment of the present invention may include a first language instruction dataset generation step (S100), a second language instruction dataset generation step (S200), a cross-language instruction generation step (S300), an instruction tuning step (S400), and an inference step (S500).

[0147] A method for performing instruction tuning of a language model using heterogeneous languages ​​according to FIG. 14. In both the instruction tuning (learning) step (S400) and the inference step (S500), cross-language instructions are applied to a first instruction tuning dataset and / or a second instruction tuning dataset.

[0148] Therefore, not only is learning (tuning) of a language model performed by applying cross-language instructions to the first instruction tuning dataset and / or the second instruction tuning dataset, but inference is also performed by applying cross-language instructions to the first instruction tuning dataset and / or the second instruction tuning dataset.

[0149] Meanwhile, the embodiments of the present invention described above may be implemented in the form of program commands that can be executed through various computer components and recorded on a computer-readable recording medium. The computer-readable recording medium may include program commands, data files, data structures, etc., either singly or in combination. The program commands recorded on the computer-readable recording medium may be specially designed and configured for the present invention or may be known and available to those skilled in the art of computer software. Examples of computer-readable recording media include magnetic media such as hard disks, floppy disks, and magnetic tapes, optical recording media such as CD-ROMs and DVDs, magneto-optical media such as floptical disks, and hardware devices specifically configured to store and execute program commands, such as ROMs, RAMs, and flash memories. Examples of program commands include not only machine language codes generated by a compiler, but also high-level language codes that can be executed by a computer using an interpreter, etc. Hardware devices may be changed into one or more software modules to perform processing according to the present invention, and vice versa.

[0150] The specific implementations described in the present invention are exemplary embodiments and do not limit the scope of the present invention in any way. For the sake of brevity, descriptions of conventional electronic components, control systems, software, and other functional aspects of the systems may be omitted. In addition, the lines connecting or connecting members between components illustrated in the drawings are merely representative of functional connections and / or physical or circuit connections, and may be replaced or represented as various additional functional connections, physical connections, or circuit connections in an actual device. In addition, unless specifically mentioned as “essential,” “important,” etc., a component may not be absolutely necessary for the application of the present invention.

[0151] Although the detailed description of the present invention has been described with reference to preferred embodiments of the present invention, it will be understood by those skilled in the art or having ordinary knowledge in the art that various modifications and changes can be made to the present invention without departing from the spirit and technical scope of the present invention as set forth in the claims below. Accordingly, the technical scope of the present invention should not be limited to the contents described in the detailed description of the specification, but should be defined by the claims.

[0152] The form for carrying out the invention is the same as the best form for carrying out the invention described above.

[0153] The present invention relates to a method and system for performing instruction tuning using a heterogeneous language, and is applicable to the artificial intelligence industry, and thus has industrial applicability.

Claims

1. A method for performing instruction tuning of a large language model (LLM) using a heterogeneous language in a computing system including a memory and a processor, A step of setting up a first instruction tuning dataset including at least one first task formed in a first language using metadata, A step of setting up a second instruction tuning dataset including at least one second task formed in a second language; Steps to generate cross-language instructions, and A step of performing instruction tuning on the first instruction tuning dataset and the second instruction tuning dataset using the cross-language instructions. Includes, The step of generating the above cross-language instructions is: generating one or more first instructions written in the first language, and A step of generating one or more second instructions written in the second language. Includes, The steps to perform the above instruction tuning are A step of performing instruction tuning on the second instruction tuning dataset using the first instruction, and performing instruction tuning on the first instruction tuning dataset using the second instruction. A method for performing instruction tuning using a heterogeneous language, wherein the first instruction and the second instruction are set to have the same format.

2. In paragraph 1, The step of setting the first instruction tuning dataset is: A step of generating N or more preset first tasks A method for performing instruction tuning using a heterogeneous language, wherein N is a natural number greater than or equal to 1.

3. In paragraph 2, The step of generating the above first instruction is: Step of generating 3N first instructions and applying 3 instructions per task A method for performing instruction tuning using a heterogeneous language, including:

4. In paragraph 3, The step of setting the first instruction tuning dataset is: Step of generating 34 NLU (Natural Language Understanding) tasks and 17 NLG (Natural Languagae Generation) tasks based on data collected from one or more of AIHub1, KorPora2, GIthub, Huggingface, KLUE3, Korquad4, ETRI5, Modui corpus, and KoBest. A method for performing instruction tuning using a heterogeneous language, including:

5. In paragraph 4, The above language model is a method for performing instruction tuning using a multilingual model.

6. A method for performing instruction tuning of a large language model (LLM) using a heterogeneous language in a computing system including a memory and a processor, A step of setting up a first instruction tuning dataset including at least one first task formed in a first language using metadata, A step of setting up a second instruction tuning dataset including at least one second task formed in a second language; Steps to generate cross-language instructions, and A step of applying the cross-language instructions to the first instruction tuning dataset and the second instruction tuning dataset to perform inference on data input to the language model. Includes, The step of generating the above cross-language instructions is: generating one or more first instructions written in the first language, and A step of generating one or more second instructions written in the second language. Includes, The steps to perform the above inference are A step of performing inference by applying the first instruction to the second instruction tuning dataset and applying the second instruction to the first instruction tuning dataset A method for performing instruction tuning using a heterogeneous language, wherein the first instruction and the second instruction are set to have the same format.

7. In paragraph 6, The step of setting the first instruction tuning dataset is: A step of generating N or more preset first tasks A method for performing instruction tuning using a heterogeneous language, wherein N is a natural number greater than or equal to 1.

8. In paragraph 7, The step of setting the above first instruction is: Step of generating 3N first instructions and applying 3 instructions per task A method for performing instruction tuning using a heterogeneous language, including:

9. In paragraph 8, The step of setting the first instruction tuning dataset is: Step of generating 34 NLU (Natural Language Understanding) tasks and 17 NLG (Natural Languagae Generation) tasks based on data collected from one or more of AIHub1, KorPora2, GIthub, Huggingface, KLUE3, Korquad4, ETRI5, Modui corpus, and KoBest. A method for performing instruction tuning using a heterogeneous language, including:

10. In paragraph 9, The above language model is a method for performing instruction tuning using a multilingual model.

11. A method for performing instruction tuning of a large language model (LLM) using a heterogeneous language in a computing system including a memory and a processor, A step of setting up a first instruction tuning dataset including at least one first task formed in a first language using metadata, A step of setting up a second instruction tuning dataset including at least one second task formed in a second language; Steps to generate cross-language instructions, A step of performing instruction tuning on the first instruction tuning dataset and the second instruction tuning dataset using the cross-language instructions, and A step of applying the cross-language instructions to the first instruction tuning dataset and the second instruction tuning dataset to perform inference on data input to the language model. Includes, The step of generating the above cross-language instructions is: generating one or more first instructions written in the first language, and A step of generating one or more second instructions written in the second language. Includes, The steps to perform the above instruction tuning are A step of performing instruction tuning on the second instruction tuning dataset using the first instruction, and performing instruction tuning on the first instruction tuning dataset using the second instruction, The steps to perform the above inference are A step of performing inference by applying the first instruction to the second instruction tuning dataset and applying the second instruction to the first instruction tuning dataset A method for performing instruction tuning using a heterogeneous language, wherein the first instruction and the second instruction are set to have the same format.

12. In paragraph 11, The step of setting the first instruction tuning dataset is: A step of generating N or more preset first tasks A method for performing instruction tuning using a heterogeneous language, wherein N is a natural number greater than or equal to 1.

13. In paragraph 12, The step of generating the above first instruction is: Step of generating 3N first instructions and applying 3 instructions per task A method for performing instruction tuning using a heterogeneous language, including:

14. In paragraph 13, The step of setting the first instruction tuning dataset is: Step of generating 34 NLU (Natural Language Understanding) tasks and 17 NLG (Natural Languagae Generation) tasks based on data collected from one or more of AIHub1, KorPora2, GIthub, Huggingface, KLUE3, Korquad4, ETRI5, Modui corpus, and KoBest. A method for performing instruction tuning using a heterogeneous language, including:

15. In paragraph 14, The above language model is a method for performing instruction tuning using a multilingual model.

16. At least one memory, and At least one processor that reads out at least one application stored in the above memory and performs instruction tuning of a language model using a heterogeneous language. Including, The above processor, A first instruction tuning dataset is set up that includes at least one first task formed in a first language using metadata, A second instruction tuning dataset is set up that includes at least one second task formed in a second language, Generating cross-language instructions comprising one or more first instructions written in a first language and one or more second instructions written in a second language, Performing instruction tuning on the first instruction tuning dataset and the second instruction tuning dataset using the cross-language instructions, A command for performing a step of performing inference on data input to the language model by applying the cross-language instruction to the first instruction tuning dataset and the second instruction tuning dataset, Performing instruction tuning on the second instruction tuning dataset using the first instruction, and performing instruction tuning on the first instruction tuning dataset using the second instruction, Applying the first instruction to the second instruction tuning dataset, and applying the second instruction to the first instruction tuning dataset to perform inference, A system for performing instruction tuning using a heterogeneous language, wherein the first instruction and the second instruction are set to have the same format.

17. At least one memory, and At least one processor that reads out at least one application stored in the above memory and performs instruction tuning of a language model using a heterogeneous language. Including, The instructions of the above processor are: A step of setting up a first instruction tuning dataset including at least one first task formed in a first language using metadata, A step of setting up a second instruction tuning dataset including at least one second task formed in a second language; Steps to generate cross-language instructions, A step of performing instruction tuning on the first instruction tuning dataset and the second instruction tuning dataset using the cross-language instructions, and A command for performing a step of performing inference on data input to the language model by applying the cross-language instruction to the first instruction tuning dataset and the second instruction tuning dataset, Includes, The step of generating the above cross-language instructions is: generating one or more first instructions written in the first language, and A step of generating one or more second instructions written in the second language. Includes, The steps to perform the above instruction tuning are A step of performing instruction tuning on the second instruction tuning dataset using the first instruction, and performing instruction tuning on the first instruction tuning dataset using the second instruction, The steps to perform the above inference are A step of performing inference by applying the first instruction to the second instruction tuning dataset and applying the second instruction to the first instruction tuning dataset A computing device, wherein the first instruction and the second instruction are set to have the same format.

Images