高速AI推論「Groq」を試す

!pip install groq

from google.colab import userdata
import os

os.environ["GROQ_API_KEY"] = userdata.get('GROQ_API_KEY')

import os
from groq import Groq

client = Groq(
    api_key=os.environ.get("GROQ_API_KEY"),
)

chat_completion = client.chat.completions.create(
    messages=[
        {
            "role": "system",
            "content": "あなたは日本語で答える親切なアシスタントです。",

        },
        {
            "role": "user",
            "content": "日本の総理大臣は誰？回答は日本語で。",
        }
    ],
    model="llama3-8b-8192",
)

print(chat_completion.choices[0].message.content)

現在の日本の内閣総理大臣は、岸田文雄閣総理大臣です。

import os
from groq import Groq

client = Groq(
    api_key=os.environ.get("GROQ_API_KEY"),
)

stream = client.chat.completions.create(
    messages=[
        {
            "role": "system",
            "content": "あなたは日本語で答える親切なアシスタントです。",

        },
        {
            "role": "user",
            "content": "日本の総理大臣は誰？回答は日本語で。",
        }
    ],
    model="llama3-8b-8192",
    stream=True,
)

for chunk in stream:
    print(chunk.choices[0].delta.content, end="\n")

😊



現在
の
日本
の
総
理
大
臣
は
、
岸
田
文
雄
（
K
ish
ida
 F
um
io
）
です
。
None

import os
import asyncio
from groq import AsyncGroq

# notebook向け
import nest_asyncio
nest_asyncio.apply()

async def main():
    client = AsyncGroq(
        api_key=os.environ.get("GROQ_API_KEY"),
    )

    chat_completion = await client.chat.completions.create(
        messages=[
            {
                "role": "system",
                "content": "あなたは日本語で答える親切なアシスタントです。",

            },
            {
                "role": "user",
                "content": "日本の総理大臣は誰？回答は日本語で。",
            }
        ],
        model="llama3-8b-8192",
        stream=False,
    )

    print(chat_completion.choices[0].message.content)

asyncio.run(main())

現在の日本の内閣総理大臣は、岸田文雄（Kishida Fumio）さんです。

import os
import asyncio
from groq import AsyncGroq

# notebook向け
import nest_asyncio
nest_asyncio.apply()

async def main():
    client = AsyncGroq(
        api_key=os.environ.get("GROQ_API_KEY"),
    )

    stream = await client.chat.completions.create(
        messages=[
            {
                "role": "system",
                "content": "あなたは日本語で答える親切なアシスタントです。",

            },
            {
                "role": "user",
                "content": "日本の総理大臣は誰？回答は日本語で。",
            }
        ],
        model="llama3-8b-8192",
        stream=True,
    )

    async for chunk in stream:
        print(chunk.choices[0].delta.content, end="\n")

asyncio.run(main())

こんにちは
！
日本
の
総
理
大
臣
は
、
菅
義
偉
（
K
ish
ida
 F
um
io
）
です
。
現在
、
第
100
代
総
理
大
臣
として
着
任
しています
。
None

import os
from groq import Groq

client = Groq(
    api_key=os.environ.get("GROQ_API_KEY"),
)

system_prompt = """
あなたは日本語で答える親切なアシスタントです。JSONで応答を返します。JSONスキーマは以下:
{
    "answer": "string",
    "metadatas": {
        "confidence_score": "number (0-1)",
        "category": "text"
    }
  }
}
"""

chat_completion = client.chat.completions.create(
    messages=[
        {
            "role": "system",
            "content": system_prompt,

        },
        {
            "role": "user",
            "content": "日本の総理大臣は誰？回答は日本語で。",
        }
    ],
    model="llama3-8b-8192",
    response_format={"type": "json_object"},
)

print(chat_completion.choices[0].message.content)

{
    "answer": "岸田文雄",
    "metadatas": {
        "confidence_score": 1.0,
        "category": " Politics"
    }
}

from groq import Groq
import os
import json

client = Groq(api_key = os.getenv('GROQ_API_KEY'))
MODEL = 'llama3-70b-8192'


# NBAの試合のスコアを返すようにハードコードされたダミー関数の例
def get_game_score(team_name):
    """NBAの試合の現在のスコアを取得する。"""
    if "ウォリアーズ" in team_name or "レイカーズ" in team_name:
        return json.dumps({
            "game_id": "401585601",
            "status": 'Final',
            "home_team": "ロサンゼルス・レイカーズ",
            "home_team_score": 121,
            "away_team": "ゴールデンステイト・ウォリアーズ",
            "away_team_score": 128
        }, ensure_ascii=False)
    elif "ナゲッツ" in team_name or "ヒート" in team_name:
        return json.dumps({
            "game_id": "401585577",
            "status": 'Final',
            "home_team": "マイアミ・ヒート",
            "home_team_score": 88,
            "away_team": "デンバー・ナゲッツ",
            "away_team_score": 100
        }, ensure_ascii=False)
    else:
        return json.dumps({
            "team_name": team_name,
            "score": "unknown"
        })

def run_conversation(user_prompt):
    # ステップ1: 会話と利用可能な関数をモデルに送る
    messages=[
        {
            "role": "system",
            "content": "あなたは、関数を呼び出すLLMです。get_game_score関数から抽出したデータを使って、NBAの試合スコアに関する質問に答えます。回答にはチームと対戦相手を含めてください。回答は常に日本語で答えるようにしてください。"
        },
        {
            "role": "user",
            "content": user_prompt,
        }
    ]
    tools = [
        {
            "type": "function",
            "function": {
                "name": "get_game_score",
                "description": "与えられたNBAの試合スコアを取得する",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "team_name": {
                            "type": "string",
                            "description": "NBAチームの名前（例: 'ゴールデンステート・ウォリアーズ')",
                        }
                    },
                    "required": ["team_name"],
                },
            },
        }
    ]
    response = client.chat.completions.create(
        model=MODEL,
        messages=messages,
        tools=tools,
        tool_choice="auto",
        max_tokens=4096
    )

    response_message = response.choices[0].message
    tool_calls = response_message.tool_calls
    # ステップ2: モデルが関数を呼び出したいかどうかをチェックする
    if tool_calls:
        # ステップ3: 関数を呼び出す
        # 注意: JSONレスポンスは常に有効であるとは限らない; 必ずエラーを処理すること
        available_functions = {
            "get_game_score": get_game_score,
        }  # この例では関数は1つだけだが、複数の関数を使うこともできる。
        messages.append(response_message)  # extend conversation with assistant's reply
        # ステップ4: 各関数の呼び出しとレスポンスの情報をモデルに送信する
        for tool_call in tool_calls:
            function_name = tool_call.function.name
            function_to_call = available_functions[function_name]
            function_args = json.loads(tool_call.function.arguments)
            function_response = function_to_call(
                team_name=function_args.get("team_name")
            )
            messages.append(
                {
                    "tool_call_id": tool_call.id,
                    "role": "tool",
                    "name": function_name,
                    "content": function_response,
                }
            )  # 関数のレスポンスで会話を拡張する
        second_response = client.chat.completions.create(
            model=MODEL,
            messages=messages
        )  # モデルから新しいレスポンスを受け取り、関数のレスポンスを確認する
        return second_response.choices[0].message.content, messages

user_prompt = "ウォリアーズの試合結果を教えて？"
response, messages = run_conversation(user_prompt)

print(response)
print("---")
print(messages)

ウォリアーズの最新の試合結果は、ロサンゼルス・レイカーズとの対戦で、ウォリアーズが128-121で勝利したようです！
---
[
    {
        'role': 'system',
        'content': 'あなたは、関数を呼び出すLLMです。get_game_score関数から抽出したデータを使って、NBAの試合スコアに関する質問に答えます。回答にはチームと対戦相手を含めてください。回答は常に日本語で答えるようにしてください。'
    },
    {
        'role': 'user',
        'content': 'ウォリアーズの試合結果を教えて？'
    },
    ChatCompletionMessage(content=None,
    role='assistant',
    function_call=None,
    tool_calls=[
        ChatCompletionMessageToolCall(id='call_ah4t',
        function=Function(arguments='{"team_name":"ゴールデンステート・ウォリアーズ"}',
        name='get_game_score'),
        type='function')
    ]
    ),
    {
        'tool_call_id': 'call_ah4t',
        'role': 'tool',
        'name': 'get_game_score',
        'content': '{"game_id": "401585601", "status": "Final", "home_team": "ロサンゼルス・レイカーズ", "home_team_score": 121, "away_team": "ゴールデンステイト・ウォリアーズ", "away_team_score": 128}'
    }
]

from groq import Groq
import os
import json

client = Groq(api_key = os.getenv('GROQ_API_KEY'))
MODEL = 'llama3-70b-8192'

def get_temperature(city: str):
    if city == "マドリード":
        return 35
    elif city == "東京":
        return 18
    elif city == "パリ":
        return 20
    else:
        return 15


tools = [
    {
        "type": "function",
        "function": {
            "name": "get_temperature",
            "description": "与えられた都市の気温を摂氏で返す",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "都市の名前。日本語で指定すること。",
                    }
                },
                "required": ["city"],
            },
        },
    }
]

def run_conversation(user_prompt):
    messages = [
        {
            "role": "system",
            "content": "あなたは親切な日本語のアシスタントです。"
        },
        {
            "role": "user",
            "content": user_prompt,
        },
    ]

    response = client.chat.completions.create(
        model=MODEL,
        messages=messages,
        tools=tools,
        tool_choice="auto",
        max_tokens=4096
    )

    response_message = response.choices[0].message
    tool_calls = response_message.tool_calls

    if tool_calls:
        messages.append(
            {
                "role": "assistant",
                "tool_calls": [
                    {
                        "id": tool_call.id,
                        "function": {
                            "name": tool_call.function.name,
                            "arguments": tool_call.function.arguments,
                        },
                        "type": tool_call.type,
                    }
                    for tool_call in tool_calls
                ],
            }
        )

        available_functions = {
            "get_temperature": get_temperature,
        }

        for tool_call in tool_calls:
            function_name = tool_call.function.name
            function_to_call = available_functions[function_name]
            function_args = json.loads(tool_call.function.arguments)
            function_response = function_to_call(**function_args)

            # 各ツールコールに個別のツールコールメッセージを作成することに注意。
            # モデルは、tool_call_idによってツールコールの結果を識別できる。
            messages.append(
                {
                    "role": "tool",
                    "content": json.dumps(function_response, ensure_ascii=False),
                    "tool_call_id": tool_call.id,
                }
            )
        
        response = client.chat.completions.create(
            model=MODEL, messages=messages, tools=tools, tool_choice="auto", max_tokens=4096
        )

        return response.choices[0].message.content, messages

user_prompt = "パリと東京とマドリードの気温を教えて。"
response, messages = run_conversation(user_prompt)

print(response)
print("---")
print(messages)

パリの気温は20度、東京の気温は18度、マドリードの気温は35度です。
---
[
    {
        'role': 'system',
        'content': 'あなたは親切な日本語のアシスタントです。'
    },
    {
        'role': 'user',
        'content': 'パリと東京とマドリードの気温を教えて。'
    },
    {
        'role': 'assistant',
        'tool_calls': [
            {
                'id': 'call_2gtj',
                'function': {
                    'name': 'get_temperature',
                    'arguments': '{"city":"パリ"}'
                },
                'type': 'function'
            },
            {
                'id': 'call_a4wd',
                'function': {
                    'name': 'get_temperature',
                    'arguments': '{"city":"東京"}'
                },
                'type': 'function'
            },
            {
                'id': 'call_d5r8',
                'function': {
                    'name': 'get_temperature',
                    'arguments': '{"city":"マドリード"}'
                },
                'type': 'function'
            }
        ]
    },
    {
        'role': 'tool',
        'content': '20',
        'tool_call_id': 'call_2gtj'
    },
    {
        'role': 'tool',
        'content': '18',
        'tool_call_id': 'call_a4wd'
    },
    {
        'role': 'tool',
        'content': '35',
        'tool_call_id': 'call_d5r8'
    }
]

!pip install datasets

from datasets import load_dataset

ds = load_dataset("reazon-research/reazonspeech", "tiny", trust_remote_code=True)

for idx, data in enumerate(ds["train"]["transcription"]):
    if len(data) > 200:
        print(idx, len(data))

870 203
3626 206

text = ds["train"]["transcription"][3626]
file_path = ds["train"]["audio"][3626]["path"]
print(text[:10] + "...")
print(file_path)

%%time
import os
from groq import Groq

client = Groq(
    api_key = os.getenv('GROQ_API_KEY')
)
 
with open(file_path, "rb") as file:
    transcription = client.audio.transcriptions.create(
        file=(file_path, file.read()),
        model="whisper-large-v3",
        prompt="Specify context or spelling",   # オプション
        response_format="json",                 # オプション
        language="ja",                          # オプション
        temperature=0.0                         # オプション
    )
    print(transcription.text)

彼女の青春はどう（snip）
CPU times: user 86.1 ms, sys: 1.76 ms, total: 87.9 ms
Wall time: 848 ms

%%time
from openai import OpenAI
from google.colab import userdata
import os

os.environ["OPENAI_API_KEY"] = userdata.get('OPENAI_API_KEY')

client = OpenAI()

with open(file_path, "rb") as file:
    transcription = client.audio.transcriptions.create(
        file=(file_path, file.read()),
        model="whisper-1",
        prompt="Specify context or spelling",
        response_format="json",
        language="ja",
        temperature=0.0
    )
    print(transcription.text)

彼女の青春はどう（snip）
CPU times: user 112 ms, sys: 8.27 ms, total: 121 ms
Wall time: 3.88 s

import os
import time
from functools import wraps
import statistics
from tqdm.auto import tqdm
from groq import Groq


def timing_decorator(repeats=1):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            times = []
            results = []
            for _ in tqdm(range(repeats), desc="Processing"):
                start_time = time.time()
                result = func(*args, **kwargs)
                results.append(result)
                end_time = time.time()
                times.append(end_time - start_time)
            avg_time = round(sum(times) / len(times),2)
            max_time = round(max(times),2)
            min_time = round(min(times),2)
            median_time = round(statistics.median(times),2)
            timing_info = {
                'avg': avg_time,
                'max': max_time,
                'min': min_time,
                'med': median_time,
                'times': [round(t, 2) for t in times]
            }
            return results[0] if repeats == 1 else results, timing_info
        return wrapper
    return decorator


@timing_decorator(repeats=10)
def groq_completion(client, model, messages):
    completion = client.chat.completions.create(
        model=model,
        messages=messages,
        temperature=0
    )
    return completion.choices[0].message.content

models = ["llama3-8b-8192", "llama3-70b-8192", "mixtral-8x7b-32768", "gemma-7b-it"]

max_model_length = max(len(model) for model in models)
format_string = "{:<20} : {:>10} {:>10} {:>10} {:>10}"

client = Groq(
    api_key = os.getenv('GROQ_API_KEY')
)

messages = [
    {"role": "system", "content": "あなたは詩的なアシスタントで、複雑なプログラミングのコンセプトをクリエイティブなセンスで説明することに長けている。"},
    {"role": "user", "content": "プログラミングにおける再帰の概念を説明する詩を作ってください。日本語で。"}
]

for model in models:
    res = groq_completion(client, model, messages)[1]
    print(format_string.format("Model", "AVG", "MIN", "MAX", "MED"))
    print(format_string.format(model, res["avg"], res["min"], res["max"], res["med"]))
    print()