Zaman serilerini ve büyük veri çerçevelerini işlemek için yapay zeka aracıları
Sadece Python ve Ollama kullanarak sıfırdan oluşturun (GPU veya API anahtarı yok)
giriş
Aracılar, büyük dil modelleri (LLM) tarafından desteklenen, hedefleri hakkında akıl yürütme ve nihai hedefe ulaşmak için eylemde bulunma yeteneğine sahip yapay zeka sistemleridir. Sadece sorgulara yanıt vermek için değil, veri işleme (veri çerçeveleri ve zaman serileri gibi) de dahil olmak üzere bir dizi işlemi düzenlemek için tasarlanmıştır. Bu yetenek, rapor otomasyonu, kodsuz sorgular ve veri temizleme ve işleme desteği gibi birçok gerçek dünya uygulamasının veri analizine erişimi demokratikleştirmesini sağlar.
Aracılar veri çerçeveleriyle iki farklı şekilde etkileşime girebilir:
- tarafından doğal dil – Büyük dil modeli (LLM), tabloyu bir metin dizisi olarak okur ve bilgi tabanına dayanarak anlamaya çalışır.
- tarafından Kod oluştur ve çalıştır – Ajan, veri kümesini bir nesne olarak işlemek için araçları etkinleştirir.
Yapay zeka aracıları, doğal dil işleme (NLP) gücünü kod yürütme hassasiyetiyle birleştirerek daha geniş bir kullanıcı yelpazesinin karmaşık veri kümeleriyle etkileşime girmesini ve değerli içgörüler elde etmesini sağlar.
Bu eğitimde size nasıl yapılacağını göstereceğim Yapay zeka aracılarını kullanarak veri çerçevelerini ve zaman serilerini işleme. Benzer durumlara kolayca uygulanabilecek bazı yararlı Python kodları sağlayacağım (sadece kopyala, yapıştır ve çalıştır) ve bu örneği çoğaltabilmeniz için her kod satırını yorumlarla açıklayacağım (makalenin sonunda tam koda giden bağlantı).
Ayar
Hazırlıklara başlayalım Ollama (pip install ollama==0.4.7), kullanıcıların bulut hizmetlerine ihtiyaç duymadan büyük açık kaynaklı dil modellerini yerel olarak çalıştırmasına olanak tanıyan, veri gizliliği ve performansı üzerinde daha fazla kontrol sağlayan bir kütüphanedir. Yerel olarak çalıştığı için sohbet verisi cihazınızdan dışarı çıkmaz.
İlk önce indirmeniz gerekiyor Ollama Web sitesinden.
Daha sonra komut isteminizde, seçtiğiniz büyük dil modelini (LLM) indirmek için komutu kullanın. Kullanacağım Qwen Alibaba'nın kendi ürünü, çünkü hem akıllı hem de hafif.
İndirme işlemi tamamlandıktan sonra Python'a geçebilir ve kod yazmaya başlayabilirsiniz.
import ollama
llm = "qwen2.5"Büyük dil modelini deneyelim:
stream = ollama.generate(model=llm, prompt='''what time is it?''', stream=True)
for chunk in stream:
print(chunk['response'], end='', flush=True)
Zaman serisi
Zaman serisi, belirli bir zaman dilimi içerisinde ölçülen veri noktalarının dizisidir ve sıklıkla analiz ve tahmin amacıyla kullanılır. Değişkenlerin zaman içinde nasıl değiştiğini görmemizi sağlar ve trendleri ve mevsimsel kalıpları belirlemek için kullanılır. Düşünülüyor Zaman serisi İstatistiksel analiz ve tahmin için güçlü bir araç.
Bir veri seti oluşturacağım. zaman serisi Örnek olarak kullanılması için sahte.
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
## create data
np.random.seed(1) #<--for reproducibility
length = 30
ts = pd.DataFrame(data=np.random.randint(low=0, high=15, size=length),
columns=['y'],
index=pd.date_range(start='2023-01-01', freq='MS', periods=length).strftime('%Y-%m'))
## plot
ts.plot(kind="bar", figsize=(10,3), legend=False, color="black").grid(axis='y')
Tipik olarak, veri kümeleri şunları içerir: Zaman serisi Ana değişkenin sütun, zamanın ise indeks olduğu gerçekten basit bir yapı.
Bunu bir dizgeye dönüştürmeden önce, hiçbir bilgiyi kaybetmemek için her şeyin bir sütun altında yer aldığından emin olmak istiyorum.
dtf = ts.reset_index().rename(columns={"index":"date"})
dtf.head()
Daha sonra veri tipini değiştirmeniz gerekir. DataFrame'den Sözlüğe.
data = dtf.to_dict(orient='records')
data[0:5]
nihayet, Sözlükten Metin Dizisine.
str_data = "\n".join([str(row) for row in data])
str_data
Artık bir dizgemiz olduğuna göre, şunu yapabiliriz: Bunu bir istemde ekleyin Herhangi bir dil modeli bunu işleyebilir. Bir veri kümesini bir istemin içine yapıştırdığınızda şu şekilde okunur: Büyük Dil Modeli (LLM) Veriler düz metindir, ancak eğitim sırasında görülen kalıplara dayanarak yapıyı ve anlamı hala anlayabilir.
prompt = f'''
Analyze this dataset, it contains monthly sales data of an online retail product:
{str_data}
'''Kolayca bir sohbete başlayabiliriz Büyük Dil Modeli (LLM). Şu anda bunun bir etken olmadığını, herhangi bir aracı bulunmadığını, yalnızca dil modelini kullandığımızı lütfen unutmayın. Her ne kadar bir bilgisayar gibi sayıları işlemese de, bunu yapar. Büyük Dil Modeli (LLM) Özellikle küçük veri kümelerinde sütun adlarını, zamana dayalı kalıpları, eğilimleri ve aykırı değerleri tanıyabilir. Analizi simüle edebilir ve sonuçları açıklayabilir, ancak bir ajan gibi kodu çalıştırmadığı için bağımsız olarak doğru hesaplamalar yapamayacaktır.
messages = [{"role":"system", "content":prompt}]
while True:
## User
q = input('
>')
if q == "quit":
break
messages.append( {"role":"user", "content":q} )
## Model
agent_res = ollama.chat(model=llm, messages=messages, tools=[])
res = agent_res["message"]["content"]
## Response
print(" >", f"\x1b[1;30m{res}\x1b[0m")
messages.append( {"role":"assistant", "content":res} )
>'
>"
Tanıma Büyük Dil Modeli (LLM) Sayılara hakimdir ve genel bağlamı, bir tarifi veya bir satır kodu anladığı gibi anlar.
Gördüğünüz gibi, kullanımı Büyük Dil Modelleri (LLMs) لتحليل Zaman serisi Hızlı içgörüler ve sohbetler için idealdir.
Ajan
Büyük dil modelleri (LLM'ler), fikir üretme ve ilk kavramları keşfetme konusunda mükemmeldir; bir aracı ise kodu yürütebilir. Bu sayede grafikleme, tahminleme ve anomali tespiti gibi daha karmaşık görevlerin üstesinden gelebilmektedir. O halde araçları yaratalım.
Bazen, "Bir Araç Olarak “Nihai Cevap” Daha etkili. Örneğin, bir etken ara sonuçlar oluşturmak için birden fazla eylem gerçekleştiriyorsa, nihai yanıt tüm bu bilgileri tutarlı bir yanıtta birleştiren araç olarak düşünülebilir. Bunu bu şekilde tasarlayarak sonuçlar üzerinde daha fazla özelleştirme ve kontrole sahip olabilirsiniz.
def final_answer(text:str) -> str:
return text
tool_final_answer = {'type':'function', 'function':{
'name': 'final_answer',
'description': 'Returns a natural language response to the user',
'parameters': {'type': 'object',
'required': ['text'],
'properties': {'text': {'type':'str', 'description':'natural language response'}}
}}}
final_answer(text="hi")Daha sonra, Kodlama Aracı.
import io
import contextlib
def code_exec(code:str) -> str:
output = io.StringIO()
with contextlib.redirect_stdout(output):
try:
exec(code)
except Exception as e:
print(f"Error: {e}")
return output.getvalue()
tool_code_exec = {'type':'function', 'function':{
'name': 'code_exec',
'description': 'Execute python code. Use always the function print() to get the output.',
'parameters': {'type': 'object',
'required': ['code'],
'properties': {
'code': {'type':'str', 'description':'code to execute'},
}}}}
code_exec("from datetime import datetime; print(datetime.now().strftime('%H:%M'))")Ayrıca, birkaç şey daha ekleyeceğim utils fonksiyonları Aracı kullanmak ve aracı çalıştırmak için.
dic_tools = {"final_answer":final_answer, "code_exec":code_exec}
# Utils
def use_tool(agent_res:dict, dic_tools:dict) -> dict:
## use tool
if "tool_calls" in agent_res["message"].keys():
for tool in agent_res["message"]["tool_calls"]:
t_name, t_inputs = tool["function"]["name"], tool["function"]["arguments"]
if f := dic_tools.get(t_name):
### calling tool
print(' >', f"\x1b[1;31m{t_name} -> Inputs: {t_inputs}\x1b[0m")
### tool output
t_output = f(**tool["function"]["arguments"])
print(t_output)
### final res
res = t_output
else:
print(' >', f"\x1b[1;31m{t_name} -> NotFound\x1b[0m")
## don't use tool
if agent_res['message']['content'] != '':
res = agent_res["message"]["content"]
t_name, t_inputs = '', ''
return {'res':res, 'tool_used':t_name, 'inputs_used':t_inputs}
>'
>'Bir aracı bir görevi çözmeye çalıştığında, hangi araçların kullanıldığını, hangi girdileri denediğini ve hangi sonuçları aldığını izlemesini istiyorum. Süreç, model nihai cevabı vermeye hazır olduğunda durdurulmalıdır.
Kodlama aracına gelince, ajanların her adımda veri çerçevesini yeniden oluşturma eğiliminde olduğunu fark ettim. O yüzden kullanacağım hafıza güçlendirme Modele veri setinin zaten var olduğunu hatırlatmak. İstenilen davranışı elde etmek için kullanılan yaygın bir hiledir. Sonuç olarak hafıza güçlendirmeleri daha anlamlı ve etkili etkileşimler kurmanıza yardımcı olur.
# Start a chat
messages = [{"role":"system", "content":prompt}]
memory = '''
The dataset already exists and it's called 'dtf', don't create a new one.
'''
while True:
## User
q = input(' >')
if q == "quit":
break
messages.append( {"role":"user", "content":q} )
## Memory
messages.append( {"role":"user", "content":memory} )
## Model
available_tools = {"final_answer":tool_final_answer, "code_exec":tool_code_exec}
res = run_agent(llm, messages, available_tools)
## Response
print(" >", f"\x1b[1;30m{res}\x1b[0m")
messages.append( {"role":"assistant", "content":res} )
Bir olay örgüsü oluşturmak, büyük dil modelinin (LLM) tek başına yapamayacağı bir şeydir. Ancak şunu unutmayın ki, aracılar görüntü üretebilseler bile onları göremezler; çünkü motor nihayetinde bir dil modelidir. Dolayısıyla olay örgüsünü sadece kullanıcı görselleştiriyor.
Aracı bir kütüphane kullanır istatistik modelleri Bir modeli eğitmek ve zaman serisini tahmin etmek.
Büyük Veri Çerçeveleriyle Başa Çıkma
Büyük dil modelleri (LLM'ler) sınırlı belleğe sahiptir ve bu da aynı anda işleyebilecekleri bilgi miktarını kısıtlar. En gelişmiş modellerde bile token sınırlamaları vardır (birkaç yüz sayfa metin). Ayrıca, büyük dil modelleri (LLM'ler), bir geri alma sistemi dahil edilmediği sürece oturumlar arasında belleği koruyamaz. Uygulamada, büyük veri çerçeveleriyle etkili bir şekilde çalışmak için geliştiriciler genellikle parçalama, artırılmış üretim (RAG), vektör veritabanları ve içeriği modele beslemeden önce özetleme gibi stratejiler kullanırlar.
Oynayabileceğimiz büyük bir veri kümesi oluşturalım.
import random
import string
length = 1000
dtf = pd.DataFrame(data={
'Id': [''.join(random.choices(string.ascii_letters, k=5)) for _ in range(length)],
'Age': np.random.randint(low=18, high=80, size=length),
'Score': np.random.uniform(low=50, high=100, size=length).round(1),
'Status': np.random.choice(['Active','Inactive','Pending'], size=length)
})
dtf.tail()
Ben ekleyeceğim Web Arama AracıBöylece Python kodlarını çalıştırabilen ve internette arama yapabilen genel amaçlı yapay zeka, mevcut tüm bilgilere erişebilir ve veri odaklı kararlar alabilir.
Python'da web arama aracı oluşturmanın en kolay yolu popüler özel tarayıcıyı kullanmaktır. DuckDuckGo (pip install duckduckgo-search==6.3.5). Orijinal kütüphaneyi doğrudan kullanabilir veya bir kabuk içe aktarabilirsiniz. Dil Zinciri (pip install langchain-community==0.3.17).
from langchain_community.tools import DuckDuckGoSearchResults
def search_web(query:str) -> str:
return DuckDuckGoSearchResults(backend="news").run(query)
tool_search_web = {'type':'function', 'function':{
'name': 'search_web',
'description': 'Search the web',
'parameters': {'type': 'object',
'required': ['query'],
'properties': {
'query': {'type':'str', 'description':'the topic or subject to search on the web'},
}}}}
search_web(query="nvidia")
Toplamda, ajanın artık 3 aracı var.
dic_tools = {'final_answer':final_answer,
'search_web':search_web,
'code_exec':code_exec}İstemde tam veri çerçevesini ekleyemediğim için, LLM'nin veri kümesinin genel bağlamını anlayabilmesi için yalnızca ilk 10 satırı besleyeceğim. Ayrıca, tam veri setinin nerede bulunabileceğini de belirteceğim.
str_data = "\n".join([str(row) for row in dtf.head(10).to_dict(orient='records')])
prompt = f'''
You are a Data Analyst, you will be given a task to solve as best you can.
You have access to the following tools:
- tool 'final_answer' to return a text response.
- tool 'code_exec' to execute Python code.
- tool 'search_web' to search for information on the internet.
If you use the 'code_exec' tool, remember to always use the function print() to get the output.
The dataset already exists and it's called 'dtf', don't create a new one.
This dataset contains credit score for each customer of the bank. Here's the first rows:
{str_data}
'''Son olarak, aracımızı çalıştırabiliriz.
messages = [{"role":"system", "content":prompt}]
memory = '''
The dataset already exists and it's called 'dtf', don't create a new one.
'''
while True:
## User
q = input(' >')
if q == "quit":
break
messages.append( {"role":"user", "content":q} )
## Memory
messages.append( {"role":"user", "content":memory} )
## Model
available_tools = {"final_answer":tool_final_answer, "code_exec":tool_code_exec, "search_web":tool_search_web}
res = run_agent(llm, messages, available_tools)
## Response
print(" >", f"\x1b[1;30m{res}\x1b[0m")
messages.append( {"role":"assistant", "content":res} )
Bu etkileşimde ajan kodlama aracını doğru bir şekilde kullanmıştır. Şimdi ona diğer aracı da kullandırmak istiyorum.
Son olarak, ajanın bu sohbetten bugüne kadar elde edilen tüm bilgileri bir araya getirmesini istiyorum.
Sonuç
Bu makale, aşağıdakileri göstermek için bir eğitim olarak tasarlanmıştır: Zaman serilerini ve büyük veri çerçevelerini işlemek için sıfırdan aracılar nasıl oluşturulur. Modellerin verilerle etkileşime girmesinin iki yolunu ele aldık: doğal dil yoluyla, yani büyük dil modeli (LLM) bilgi tabanını kullanarak bir tabloyu bir dize olarak yorumlayarak ve kod üretip çalıştırarak, veri kümesini bir nesne olarak işlemek için araçlardan yararlanarak.
Bu makalenin tam kodu: GitHub
Umarım beğenmişsinizdir! Sorularınız, yorumlarınız veya ilginç projelerinizi paylaşmak için benimle iletişime geçmekten çekinmeyin.
Yoruma kapalı.