AI агенти: Времеви редове и големи данни

Отприщване на силата на AI агентите за овладяване на времеви редове и големи Dataframe

Изкуственият интелект (AI) бързо трансформира пейзажа на анализа на данни и в челните редици на тази революция са AI агентите. Тези сложни системи, задвижвани от големи езикови модели (LLM), притежават забележителната способност да разсъждават върху целите и да изпълняват действия за постигане на конкретни цели. За разлика от традиционните AI системи, които просто отговарят на запитвания, AI агентите са проектирани да организират сложни последователности от операции, включително сложното обработване на данни, като например dataframes и времеви редове. Тази възможност отключва множество реални приложения, демократизира достъпа до анализ на данни и дава възможност на потребителите да автоматизират отчитането, да извършват заявки без код и да получават несравнима поддръжка при почистване и манипулиране на данни.

Навигиране в Dataframe с AI агенти: Два отделни подхода

AI агентите могат да взаимодействат с dataframes, използвайки два коренно различни подхода, всеки със своите силни и слаби страни:

• Взаимодействие на естествен език: При този подход LLM щателно анализира таблицата като низ, използвайки своята обширна база знания, за да разбере данните и да извлече смислени прозрения. Този метод се отличава с разбирането на контекста и взаимоотношенията в данните, но може да бъде ограничен от присъщото на LLM разбиране на числени данни и способността му да извършва сложни изчисления.

• Генериране и изпълнение на код: Този подход включва AI агента да активира специализирани инструменти за обработка на набора от данни като структуриран обект. Агентът генерира и изпълнява фрагменти от код, за да извърши специфични операции върху dataframe, което позволява прецизна и ефикасна манипулация на данни. Този метод блести, когато се занимава с числени данни и сложни изчисления, но изисква по-високо ниво на техническа експертиза за внедряване и поддръжка.

Чрез безпроблемното интегриране на силата на обработката на естествен език (NLP) с прецизността на изпълнението на код, AI агентите дават възможност на разнообразна гама от потребители да взаимодействат със сложни набори от данни и да извличат ценни прозрения, независимо от техните технически умения.

Практически урок: Обработка на Dataframe и времеви редове с AI агенти

В този изчерпателен урок ще се впуснем в пътешествие, за да проучим практическите приложения на AI агентите при обработката на dataframes и времеви редове. Ще се задълбочим в колекция от полезни фрагменти от Python код, които могат лесно да бъдат приложени към широк спектър от подобни сценарии. Всеки ред код ще бъде щателно обяснен с подробни коментари, гарантиращи, че можете без усилие да възпроизведете примерите и да ги адаптирате към вашите специфични нужди.

Подготовка на сцената: Представяне на Ollama

Нашето проучване започва с настройката на Ollama, мощна библиотека, която дава възможност на потребителите да стартират LLM с отворен код локално, елиминирайки необходимостта от облачни услуги. Ollama осигурява несравним контрол върху поверителността и производителността на данните, като гарантира, че вашите чувствителни данни остават сигурно на вашата машина.

За да започнете, инсталирайте Ollama, като използвате следната команда:

1

curl -fsSL https://ollama.ai/install.sh | sh

След като инсталацията приключи, можете да стартирате Ollama, като използвате командата ollama serve. Това ще стартира сървър във фонов режим, готов да обслужва заявки за различни LLM.

Сега трябва да тестваме LLM. Можете да използвате следния код, за да изтеглите и стартирате llama2 LLM, уважаван модел, известен със своите възможности за генериране на текст:

1
2
3

from langchain.llms import Ollama
llm = Ollama(model="llama2")
llm("Каква е столицата на Франция?")

Този код инициализира инстанция на класа Ollama, указвайки модела llama2. След това изпраща заявка до LLM, питайки за столицата на Франция. LLM обработва заявката и връща отговора: “Столицата на Франция е Париж.”

Този прост пример демонстрира лекотата, с която можете да интегрирате Ollama и LLM в своите Python проекти, отваряйки свят от възможности за задачи за обработка на естествен език.

Изследване на силата на агентите на Langchain

С Ollama и LLM на място, ние сме готови да се потопим в завладяващото царство на агентите на Langchain. Агентите на Langchain са мощни инструменти, които позволяват на LLM да взаимодействат с външни инструменти и ресурси, разширявайки техните възможности отвъд генерирането на текст.

За да започнем, трябва да инсталираме Langchain и свързаните с него зависимости:

1

pip install -U langchain langchain-experimental pandas

След като Langchain бъде инсталиран, можем да създадем агент, който може да взаимодейства с Python interpreter. Този агент може да изпълнява Python код, което му позволява да извършва изчисления, да манипулира данни и да автоматизира задачи.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

import pandas as pd
from langchain.agents import create_pandas_dataframe_agent
from langchain.llms import Ollama

df = pd.DataFrame({
    "Име": ["Алиса", "Боб", "Чарли", "Дейвид", "Ева"],
    "Възраст": [25, 30, 22, 28, 24],
    "Град": ["Ню Йорк", "Лондон", "Париж", "Токио", "Сидни"]
})

llm = Ollama(model="llama2")
agent = create_pandas_dataframe_agent(llm, df, verbose=True)

agent.run("Каква е средната възраст?")

В този пример първо създаваме dataframe на Pandas, съдържащ информация за име, възраст и град за пет души. След това инициализираме LLM и създаваме агент на Langchain, използвайки функцията create_pandas_dataframe_agent. Този агент е оборудван да взаимодейства с dataframe на Pandas и да изпълнява Python код въз основа на заявки на естествен език.

Когато изпълним кода, агентът анализира заявката “Каква е средната възраст?”, генерира подходящия Python код за изчисляване на средната възраст и го изпълнява. След това агентът връща резултата, който е средната възраст на хората в dataframe.

Този пример демонстрира силата на агентите на Langchain при автоматизиране на задачи за анализ на данни и предоставяне на прозрения, базирани на данни.

Разгръщане на AI агенти за анализ на времеви редове

В допълнение към обработката на dataframes, AI агентите могат да бъдат приложени и за анализ на времеви редове, което е от решаващо значение за прогнозиране, откриване на аномалии и анализ на тенденции.

За тази цел можем да използваме библиотеката StatsForecast, която предлага набор от инструменти и модели за анализ на времеви редове.

Първо, трябва да инсталираме StatsForecast:

1

pip install statsforecast

След като StatsForecast бъде инсталиран, можем да създадем агент, който може да взаимодейства с обекти на времеви редове и да изпълнява прогнозни задачи.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

import pandas as pd
from statsforecast import StatsForecast
from statsforecast.models import AutoARIMA
from langchain.agents import initialize_agent, Tool
from langchain.llms import Ollama

# Създайте примерни данни за времеви редове
data = {
    'ds': pd.to_datetime(['2023-01-01', '2023-01-02', '2023-01-03', '2023-01-04', '2023-01-05']),
    'y': [10, 12, 15, 13, 17],
    'unique_id': ['series_1'] * 5  # Добавете колона unique_id
}
df = pd.DataFrame(data)

# Инициализирайте модела StatsForecast
sf = StatsForecast(
    models=[AutoARIMA(season_length=1)],
    freq='D',
    n_jobs=1
)

# Дефинирайте функция за обучение и прогнозиране на модела
def forecast(history: pd.DataFrame, periods: int):
    """Обучава модел на StatsForecast и прави прогнози.

    Args:
        history: DataFrame с исторически данни за времеви редове.
        periods: Брой периоди за прогнозиране.

    Returns:
        DataFrame с прогнозите.
    """
    sf.fit(history)
    forecast_df = sf.predict(h=periods)
    return forecast_df

# Инициализирайте LLM
llm = Ollama(model="llama2")

# Създайте инструмент за прогнозиране
tools = [
    Tool(
        name="forecast",
        func=forecast,
        description="Използвайте този инструмент, когато трябва да прогнозирате времеви редове. Входът трябва да бъде DataFrame с исторически данни и броя на периодите за прогнозиране.",
    )
]

# Инициализирайте агента
agent = initialize_agent(tools, llm, agent="zero-shot-react-description", verbose=True)

# Изпълнете агента с заявка
agent.run("Прогнозирайте следващите 3 дни.")

В този пример първо създаваме примерни данни за времеви редове, съдържащи колони за време (ds), стойност (y) и уникален идентификатор (unique_id). След това инициализираме модела StatsForecast с модела AutoARIMA и честота от 1 ден.

След това дефинираме функция forecast, която приема DataFrame с исторически данни и броя на периодите за прогнозиране като входни данни. Функцията обучава модела StatsForecast върху историческите данни и прави прогнози за посочения брой периоди.

След това инициализираме LLM и създаваме инструмент за прогнозиране, използвайки функцията forecast. След това инициализираме агента на Langchain, предоставяйки инструмента за прогнозиране и LLM.

Когато изпълним кода, агентът анализира заявката “Прогнозирайте следващите 3 дни.”, извиква инструмента за прогнозиране с подходящите входни данни и връща прогнозите.

Този пример демонстрира как AI агентите могат да бъдат използвани за автоматизиране на задачи за анализ на времеви редове и предоставяне на прогнози, базирани на данни.

Разширени техники: Вериги за данни

За по-сложни сценарии можем да използваме вериги за данни, които са последователности от свързани задачи, които могат да бъдат изпълнени от AI агент. Веригите за данни ни позволяват да създаваме персонализирани работни процеси за анализ на данни и да автоматизираме сложни задачи.

Например, можем да създадем верига за данни, която почиства данните, извършва feature engineering и обучава модел за машинно обучение.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

from langchain.chains import LLMChain
from langchain.llms import Ollama
from langchain.prompts import PromptTemplate

# Инициализирайте LLM
llm = Ollama(model="llama2")

# Дефинирайте шаблон за почистване на данни
clean_data_template = """
Вие сте експерт по почистване на данни. Като се има предвид този суров текст:
{text}
Моля, почистете и стандартизирайте текста.
"""
clean_data_prompt = PromptTemplate(input_variables=["text"], template=clean_data_template)
clean_data_chain = LLMChain(llm=llm, prompt=clean_data_prompt)

# Дефинирайте шаблон за feature engineering
feature_engineering_template = """
Вие сте експерт по feature engineering. Като се има предвид този почистен текст:
{text}
Моля, извлечете полезни характеристики от текста.
"""
feature_engineering_prompt = PromptTemplate(input_variables=["text"], template=feature_engineering_template)
feature_engineering_chain = LLMChain(llm=llm, prompt=feature_engineering_prompt)

# Дефинирайте шаблон за обучение на модел
train_model_template = """
Вие сте експерт по машинно обучение. Като се имат предвид тези характеристики:
{features}
Моля, обучете модел за машинно обучение за прогнозиране на цели.
"""
train_model_prompt = PromptTemplate(input_variables=["features"], template=train_model_template)
train_model_chain = LLMChain(llm=llm, prompt=train_model_template)

# Създайте верига за данни
data_chain = clean_data_chain | feature_engineering_chain | train_model_chain

# Изпълнете веригата за данни
raw_text = "Това е мръсен текст, който трябва да бъде почистен."
results = data_chain.invoke({"text": raw_text})

# Отпечатайте резултатите
print(results)

В този пример първо инициализираме LLM. След това дефинираме три шаблона: един за почистване на данни, един за feature engineering и един за обучение на модел. Всеки шаблон определя подкана, която се използва за насочване на LLM към извършване на конкретна задача.

След това създаваме три вериги LLMChain, една за всяка задача. Всяка верига LLMChain се състои от LLM и шаблон.

Накрая създаваме верига за данни, като свързваме трите вериги LLMChain. Операторът | се използва за свързване на веригите заедно.

Когато изпълним кода, веригата за данни първо почиства текста, след това извлича характеристики от почистения текст и накрая обучава модел за машинно обучение за прогнозиране на цели.

Този пример демонстрира как веригите за данни могат да бъдат използвани за създаване на персонализирани работни процеси за анализ на данни и автоматизиране на сложни задачи.

Заключение

AI агентите революционизират начина, по който взаимодействаме с данни, предоставяйки мощни инструменти за автоматизиране на анализ на данни, извличане на прозрения и вземане на решения, базирани на данни. Чрез комбиниране на силата на LLM с възможностите на външни инструменти и ресурси, AI агентите дават възможност на потребителите от всякакъв произход да използват пълния потенциал на своите данни.

Докато AI агентите продължават да се развиват, можем да очакваме да видим още по-иновативни приложения в широк спектър от индустрии, от финанси и здравеопазване до търговия на дребно и производство. Възможностите са безкрайни и бъдещето на анализа на данни е светло с обещанието за AI агенти.