विचार का पेड़ (ToT) तकनीक
ट्री ऑफ थॉट्स एक भाषा मॉडल प्रॉम्प्ट तकनीक है जिसे याओ और लॉन्ग ने 2023 में प्रकाशित अपने पेपर <ट्री ऑफ थॉट्स (टीओटी: ए फ्रेमवर्क फॉर एडवांस्ड प्रॉब्लम सॉल्विंग) में प्रस्तावित किया है। यह एक जटिल कार्य है जिसके लिए रणनीतिक सोच और अन्वेषण की आवश्यकता होती है के लिए विशेष रूप से उपयुक्त है। टीओटी व्यवस्थित समस्या समाधान के लिए एक खोज एल्गोरिदम के साथ संयुक्त विचारों की पेड़ जैसी संरचना का लाभ उठाकर चेन-ऑफ-थॉट (सीओटी) संकेतों की अवधारणा का विस्तार करता है।
Large Language Model Guided Tree-of-Thought.pdf388.93KB
Tree of Thoughts- Deliberate Problem Solving with Large Language Models.pdf748.36KB
टीओटी कैसे काम करता है
सीधे शब्दों में कहें तो ट्री ऑफ थॉट्स (टीओटी) तकनीक एक पेड़ जैसी संरचना है जो किसी समस्या को हल करने और इष्टतम समाधान खोजने में कई संभावनाओं की खोज करने की प्रक्रिया को व्यक्त करती है। यह भाषा मॉडल को एक इंसान की तरह कई दिशाओं पर विचार करने और यदि आवश्यक हो तो वापस जाकर एक अलग दृष्टिकोण आज़माने की अनुमति देता है।
टीओटी ध्यान क्यों आकर्षित कर रहा है?
•
वृक्ष संरचना: टीओटी एक पेड़ की शाखाओं की तरह, विभिन्न रास्तों के माध्यम से समस्या-समाधान प्रक्रिया का पता लगाता है। प्रत्येक 'शाखा' समस्या को हल करने की दिशा में एक विचार या कदम का प्रतिनिधित्व करती है। (आप उस फ़ोल्डर संरचना के बारे में सोच सकते हैं जिसे हम आमतौर पर एक्सप्लोरर में देखते हैं।)
•
विचारों को उत्पन्न करना और उनका मूल्यांकन करना: जिस प्रकार मनुष्य किसी समस्या को हल करने के लिए कई विचारों के बारे में सोचता है और मूल्यांकन करता है कि कौन सा सबसे अच्छा है, एक भाषा मॉडल कई समाधान प्रस्तुत करता है और इष्टतम समाधान ढूंढता है।
•
अन्वेषण और पीछे हटना: किसी समस्या को हल करने के लिए कई रास्तों का अन्वेषण करना, पीछे जाकर आवश्यकता पड़ने पर एक अलग दिशा में सोचना।
व्यावहारिक अनुप्रयोग
सीओटी के साथ समस्या यह है कि आप प्रतिगमन नहीं कर सकते। यदि आपको अंत तक जाना है और परिणाम देखना है और फिर जारी रखना है, तो टीओटी की सबसे बड़ी अपील यह है कि आप बीच में लौट सकते हैं और सुधार कर सकते हैं। जैसा कि पहले उल्लेख किया गया है, मान लीजिए कि आप गणित की एक समस्या हल कर रहे हैं जो एलएलएम के लिए कठिन है। उदाहरण के लिए, मान लें कि नीचे दी गई प्रश्नोत्तरी जैसी कोई प्रश्नोत्तरी है।
"4x4 스도쿠 퍼즐의 빈 칸을 채워 넣으시오."सामान्य विधि
•
प्रगति: सामान्य तरीके से, प्रत्येक पंक्ति, स्तंभ और 2x2 ग्रिड में लुप्त संख्याओं को एक-एक करके ढूंढें और रिक्त स्थान भरें।
•
परिणाम: रिक्त स्थानों को क्रमानुसार भरकर पहेली को पूरा करें।
मेरे द्वारा बनाई गई 4x4 सुडोकू पहेली में, सभी कक्ष रिक्त हैं। तो इस पहेली को हल करने के लिए पूरा सुडोकू बोर्ड इस तरह दिखेगा:
1 2 3 4
3 4 1 2
2 1 4 3
4 3 2 1
3 4 1 2
2 1 4 3
4 3 2 1
टीओटी तकनीक
ToT प्रोसेस प्रॉम्प्ट जोड़ें
•
चरण 1: भाषा मॉडल पहले रिक्त स्थान को भरने के लिए एक संख्या सुझाता है।
•
चरण 2: उन संख्याओं पर विचार करें जो अगले रिक्त स्थान में जाएंगी।
•
बैकट्रैकिंग: यदि किसी निश्चित चरण पर पहेली को हल नहीं किया जा सकता है, तो भाषा मॉडल पिछले चरण पर वापस जाता है और एक अलग संख्या का प्रयास करता है।
•
अंतिम आउटपुट: सभी रिक्त स्थानों को सही ढंग से भरकर पहेली को पूरा करें।
हमने 4x4 सुडोकू पहेली को चरण दर चरण हल करने की प्रक्रिया अपनाई, सभी रिक्त स्थानों को सही ढंग से भरने के लिए कुल 14 कदम उठाए। अंतिम पूर्ण सुडोकू पहेली इस प्रकार है:
1 2 3 4
3 4 2 1
4 3 1 2
2 1 4 3
3 4 2 1
4 3 1 2
2 1 4 3
दरअसल, अगर आप इसे इस तरह से देखें, तो आप वास्तव में अंतर नहीं देख पाएंगे। हालाँकि, यदि आप उस कोड को देखें जिसे इस मित्र ने हल किया है, तो आप समझ जायेंगे।
सामान्य शीघ्र विधि
# 4x4 Sudoku puzzle generator and solver
import numpy as np
import random
def is_safe(grid, row, col, num):
"""
Check if it's safe to place a number in a given position.
"""
# Check if we find the same num in the similar row
for x in range(4):
if grid[row][x] == num:
return False
# Check if we find the same num in the similar column
for x in range(4):
if grid[x][col] == num:
return False
# Check if we find the same num in the particular 2x2 matrix
start_row = row - row % 2
start_col = col - col % 2
for i in range(2):
for j in range(2):
if grid[i + start_row][j + start_col] == num:
return False
return True
def solve_sudoku(grid, row, col):
"""
Solving the puzzle using backtracking
"""
# Check if we have reached the 4x4 matrix end
if row == 3 and col == 4:
return True
# Check if column value becomes 4, we move to next row
if col == 4:
row += 1
col = 0
# Check if the current position is filled
if grid[row][col] > 0:
return solve_sudoku(grid, row, col + 1)
for num in range(1, 5):
# Check if it is safe to place the num
if is_safe(grid, row, col, num):
grid[row][col] = num
# Checking for next possibility with next column
if solve_sudoku(grid, row, col + 1):
return True
# Removing the assigned num
grid[row][col] = 0
return False
def generate_sudoku():
"""
Generate a 4x4 sudoku puzzle
"""
grid = np.zeros((4,4), dtype=int)
# Filling the diagonal 2x2 matrices
for i in range(0, 4, 2):
num = 1
for j in range(i, i+2):
for k in range(i, i+2):
grid[j][k] = num
num += 1
# Removing random numbers to create the puzzle
for i in range(4):
remove = random.randint(1,2) # Number of digits to remove from each row
while remove > 0:
col = random.randint(0,3)
if grid[i][col] != 0:
grid[i][col] = 0
remove -= 1
return grid
# Generate a 4x4 sudoku puzzle
puzzle = generate_sudoku()
puzzle_original = np.copy(puzzle)
# Solve the puzzle
solve_sudoku(puzzle, 0, 0)
puzzle, puzzle_original
टीओटी विधि
# Function to find the next empty cell in the sudoku grid
def find_empty_location(grid):
for row in range(4):
for col in range(4):
if grid[row][col] == 0:
return row, col
return -1, -1
# Function to check if a number can be placed in a specific cell
def is_valid(grid, row, col, num):
# Row check
if num in grid[row]:
return False
# Column check
if num in [grid[i][col] for i in range(4)]:
return False
# 2x2 square check
start_row, start_col = 2 * (row // 2), 2 * (col // 2)
for i in range(start_row, start_row + 2):
for j in range(start_col, start_col + 2):
if grid[i][j] == num:
return False
return True
# Function to solve the sudoku using backtracking
def solve_sudoku_step_by_step(grid, step=0):
row, col = find_empty_location(grid)
# If there is no empty location, we are done
if row == -1:
return True, grid, step
for num in range(1, 5):
if is_valid(grid, row, col, num):
grid[row][col] = num
solved, final_grid, next_step = solve_sudoku_step_by_step(grid, step + 1)
if solved:
return True, final_grid, next_step
# Undo the current cell for backtracking
grid[row][col] = 0
return False, grid, step
# Generate a 4x4 sudoku puzzle with some empty spaces
sudoku_puzzle = np.array([
[1, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 2],
[0, 0, 0, 0]
])
# Solve the sudoku step by step
solved, final_sudoku, steps = solve_sudoku_step_by_step(sudoku_puzzle)
final_sudoku, steps
यदि यह GPT-3.5 में किया गया है, तो आप इसे निम्नानुसार जांच सकते हैं।
जैसा कि आप परिणामों से देख सकते हैं, यह कहा जा सकता है कि हम GPT-4 के साथ जो कर सकते हैं उसे इन संकेतों का उपयोग करके तकनीकों का उपयोग करके GPT-3.5 या LLaMA2 के साथ पर्याप्त रूप से पुन: प्रस्तुत किया जा सकता है। (भले ही आप केवल GPT-4 का उपयोग करें, आप इसे केवल कोडिंग के साथ हल कर सकते हैं।
ⓒ 2023. हेबॉम, सभी अधिकार सुरक्षित।
कॉपीराइट धारक की अनुमति से इसका उपयोग वाणिज्यिक प्रयोजनों के लिए किया जा सकता है, बशर्ते स्रोत का उल्लेख किया जाए।
