ChatGPTやその他のLLMに対して実際に送っているプロンプトのデータを大規模に集めたアンケートとかデータセットを調べて。英語で
dollyっていうデータセットの日本語版を調べて

"config_dict = config.__class__.__dict__.items()
print(config_dict)

# ModelConfigクラスを辞書に変換
config_dict_raw = {key: value for key, value in config_dict}
print(config_dict_raw)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
/tmp/ipython-input-1660747023.py in <cell line: 0>()
      1 # ModelConfigクラスを辞書に変換
----> 2 config_dict_raw = {key: value for key, value in config_dict}
      3 print(config_dict_raw)

ValueError: too many values to unpack (expected 2)"
finewebとかweb corpus をクロールするような ipynbファイルのnotebook形式の教材を探してください
"以下について、擬似データサンプルを1つ用意して、コード1行ごとにそのサンプルがどう変化していくかをコメントアウトで示して

from datasketch import MinHash, MinHashLSH

lsh = MinHashLSH(threshold=0.8, num_perm=128)
minhash_store = {}

def is_duplicate(text: str) -> bool:
    m = MinHash(num_perm=128)
    for w in text.split():
        m.update(w.encode(""utf8""))
    # 既存と似ていれば重複とみなす
    if lsh.query(m):
        return True
    # 初めてなら登録
    key = str(len(minhash_store))
    lsh.insert(key, m)
    minhash_store[key] = True
    return False

# 具体例に適用（最初は False のはず）
print(""is_duplicate? "", is_duplicate(raw_text))
# 同じテキストでもう一度聞くと True になる
print(""is_duplicate again? "", is_duplicate(raw_text))"
"以下のnotebookを原稿にしつつ、初心者フレンドリーに簡素化して欲しい

# 現在のスタイル
あらかじめガッツリ関数を決めてから、大量の具体例で実践する

上記は順番としてわかりづらい。

# 理想のスタイル

具体例は1つだけに絞り、一番最初に用意する。

関数を1つずつ定義しながら、徐々に最初の具体例に対して適用していく


# 原稿


import numpy as np # linear algebra
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import os
for dirname, _, filenames in os.walk('/kaggle/input'):
    for filename in filenames:
        print(os.path.join(dirname, filename))


!pip install requests beautifulsoup4 langdetect datasketch fake_useragent

import re
import time
import requests
from bs4 import BeautifulSoup
from langdetect import detect
from datasketch import MinHash, MinHashLSH
from urllib.parse import urlparse, urljoin
from fake_useragent import UserAgent

# MinHash LSH for deduplication
minhash_lsh = MinHashLSH(threshold=0.8, num_perm=128)
minhash_store = {}

# User-Agent Rotator to Avoid Blocking
ua = UserAgent()

# Crawling settings
MAX_PAGES = 20  # Limit number of pages to crawl
CRAWL_DEPTH = 2  # How deep to crawl links

visited_urls = set()

# Crawl theweb dynamically
def crawl_web(seed_urls, depth=CRAWL_DEPTH):
    """"""Crawls web starting from seed URLs.""""""
    to_crawl = [(url, 0) for url in seed_urls]  # (URL, depth)
    crawled_data = []
    
    while to_crawl and len(crawled_data) < MAX_PAGES:
        url, current_depth = to_crawl.pop(0)
        
        if url in visited_urls or current_depth > depth:
            continue
        
        visited_urls.add(url)
        print(f""Crawling: {url}"")

        text, links = extract_text_and_links(url)
        if text:
            crawled_data.append(text)

        if current_depth < depth:
            to_crawl.extend([(link, current_depth + 1) for link in links if link not in visited_urls])
    
    return crawled_data

# Extracting text and links from page
def extract_text_and_links(url):
    """"""Fetch text content and discover new links from a webpage.""""""
    try:
        headers = {""User-Agent"": ua.random}
        response = requests.get(url, headers=headers, timeout=5)
        response.raise_for_status()

        soup = BeautifulSoup(response.text, ""html.parser"")
        text = "" "".join(p.get_text() for p in soup.find_all(""p""))
        links = {urljoin(url, a[""href""]) for a in soup.find_all(""a"", href=True)}

        return text.strip(), links
    except requests.RequestException:
        return """", set()

# Language Filtering
def filter_language(text, target_lang=""en""):
    try:
        return detect(text) == target_lang
    except:
        return False

# Step 3: Gopher Filtering - Remove unwanted words
UNWANTED_KEYWORDS = [""click here"", ""advertisement"", ""sign up"", ""subscribe""]

def gopher_filter(text):
    return not any(keyword in text.lower() for keyword in UNWANTED_KEYWORDS)

# MinHash Deduplication
def is_duplicate(text):
    m = MinHash(num_perm=128)
    for word in text.split():
        m.update(word.encode(""utf8""))
    
    if len(minhash_lsh.query(m)) > 0:
        return True
    
    key = len(minhash_store)
    minhash_lsh.insert(str(key), m)
    minhash_store[key] = text
    return False

# Step 5: C4 Filters - Remove low-quality text
def c4_filters(text):
    return len(text.split()) > 50  # Keep meaningful content

# Step 6: PII Removal - Emails, phone numbers, etc.
def remove_pii(text):
    text = re.sub(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,7}\b', ""[EMAIL REDACTED]"", text)
    text = re.sub(r'\b\d{10,13}\b', ""[PHONE REDACTED]"", text)
    return text

# Pipeline Execution
def fineweb_pipeline(seed_urls):
    """"""Crawl web and process text through the FineWeb pipeline.""""""
    raw_texts = crawl_web(seed_urls)
    clean_texts = []

    for text in raw_texts:
        if not filter_language(text):
            continue
        if not gopher_filter(text):
            continue
        if is_duplicate(text):
            continue
        if not c4_filters(text):
            continue

        clean_texts.append(remove_pii(text))

    return clean_texts

# Use Case
seed_urls = [
    ""https://en.wikipedia.org/wiki/Web_crawler"",
    ""https://www.bbc.com/news""
]

clean_data = fineweb_pipeline(seed_urls)

for i, text in enumerate(clean_data):
    print(f""\n--- Processed Text {i+1} ---\n{text[:500]}"")  # First 500 chars


import re
import time
import requests
import pandas as pd
from bs4 import BeautifulSoup
from langdetect import detect
from datasketch import MinHash, MinHashLSH
from urllib.parse import urlparse, urljoin
from fake_useragent import UserAgent

# MinHash LSH for deduplication
minhash_lsh = MinHashLSH(threshold=0.8, num_perm=128)
minhash_store = {}

# User-Agent Rotator to Avoid Blocking
ua = UserAgent()

# Crawling settings
MAX_PAGES = 100  # Maximum number of pages to crawl
CRAWL_DEPTH = 2  # How deep to crawl links
SEED_URLS = [
    ""https://en.wikipedia.org/wiki/Web_crawler"",
    ""https://www.bbc.com/news"",
    ""https://www.cnn.com"",
    ""https://www.theguardian.com/international"",
    ""https://www.nytimes.com""
]

visited_urls = set()

# Web Crawler
def crawl_web(seed_urls, depth=CRAWL_DEPTH):
    """"""Crawls the web starting from given seed URLs.""""""
    to_crawl = [(url, 0) for url in seed_urls]  # (URL, depth)
    crawled_data = []
    
    while to_crawl and len(crawled_data) < MAX_PAGES:
        url, current_depth = to_crawl.pop(0)
        
        if url in visited_urls or current_depth > depth:
            continue
        
        visited_urls.add(url)
        print(f""Crawling: {url}"")

        text, links = extract_text_and_links(url)
        if text:
            crawled_data.append({""url"": url, ""text"": text})

        if current_depth < depth:
            to_crawl.extend([(link, current_depth + 1) for link in links if link not in visited_urls])
    
    return crawled_data

# Extract text and links from page
def extract_text_and_links(url):
    """"""Fetch text content and discover new links from a webpage.""""""
    try:
        headers = {""User-Agent"": ua.random}
        response = requests.get(url, headers=headers, timeout=5)
        response.raise_for_status()

        soup = BeautifulSoup(response.text, ""html.parser"")
        text = "" "".join(p.get_text() for p in soup.find_all(""p""))
        links = {urljoin(url, a[""href""]) for a in soup.find_all(""a"", href=True)}

        return text.strip(), links
    except requests.RequestException:
        return """", set()

# Language Filtering
def filter_language(text, target_lang=""en""):
    try:
        return detect(text) == target_lang
    except:
        return False

# Gopher Filtering - Removal of unwanted words
UNWANTED_KEYWORDS = [""click here"", ""advertisement"", ""sign up"", ""subscribe""]

def gopher_filter(text):
    return not any(keyword in text.lower() for keyword in UNWANTED_KEYWORDS)

# MinHash Deduplication
def is_duplicate(text):
    m = MinHash(num_perm=128)
    for word in text.split():
        m.update(word.encode(""utf8""))
    
    if len(minhash_lsh.query(m)) > 0:
        return True
    
    key = len(minhash_store)
    minhash_lsh.insert(str(key), m)
    minhash_store[key] = text
    return False

# C4 Filters - Removal of low-quality text
def c4_filters(text):
    return len(text.split()) > 50  # Only eaningful content

# PII Removal - Emails, phone numbers, etc.
def remove_pii(text):
    text = re.sub(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,7}\b', ""[EMAIL REDACTED]"", text)
    text = re.sub(r'\b\d{10,13}\b', ""[PHONE REDACTED]"", text)
    return text

# Pipeline Execution
def fineweb_pipeline(seed_urls):
    """"""Crawl web & process text through FineWeb pipeline.""""""
    raw_data = crawl_web(seed_urls)
    clean_data = []

    for entry in raw_data:
        text = entry[""text""]
        url = entry[""url""]

        if not filter_language(text):
            continue
        if not gopher_filter(text):
            continue
        if is_duplicate(text):
            continue
        if not c4_filters(text):
            continue

        clean_text = remove_pii(text)
        clean_data.append({""url"": url, ""text"": clean_text})

    return clean_data


def save_dataset(data, filename=""fineweb_dataset""):
    """"""Save data in CSV and JSON formats.""""""
    df = pd.DataFrame(data)
    df.to_csv(f""{filename}.csv"", index=False, encoding=""utf-8"")
    df.to_json(f""{filename}.json"", orient=""records"", indent=4)

    print(f""\nDataset saved as {filename}.csv and {filename}.json"")

# Use Case
clean_data = fineweb_pipeline(SEED_URLS)


save_dataset(clean_data)


for i, entry in enumerate(clean_data[:3]):
    print(f""\n--- Processed Text {i+1} from {entry['url']} ---\n{text[:500]}"")  # First 500 chars"
ChatGPTは1日にどれだけのトークンを生成していますか？
愛知　名古屋以外のふつうの町　アウトドア　雨の日　できること考えて
レポ技術同人誌ってなんですか
いっぺんの長さが1センチメートルから
Streamlitで無料でデプロイできるのってどのくらいのサイズの言語もでるまで？
wandbのチームプランについて、学生向けライセンスやアカウントでチームプランって組める？
お金のかからないレクリエーション
microsoftのAI研究員の数を調べて
東大のMIYABI　GPU パソコンを学生が使う方法と料金をブラウザで検索して
今日ドライブ旅行してるんだけど、前日にわくわくしすぎてずっと目が覚めてて、1.5時間くらいしか寝られなかった、、
"# ModelConfigクラスを辞書に変換
config_dict = {k: v for k, v in config.__class__.__dict__.items() if not k.startswith(""__"")}
print(config_dict)"
"import pandas as pd
# pandas の DataFrame に変換
df = pd.DataFrame(results)"
"以下の文章を、具体的な意味が伝わるようにしつつも、もっと簡潔にしてほしい

`train`関数がどんどん長くなってますね。

特に、条件分岐`if`文が増えて読みづらくなっています。

コードの可読性を高めるために、リファクタリングを行います。

条件分岐`if`文を減らすために、最後のステップと評価ステップを揃えたいと思います。

`for step in range(self.config.total_training_steps):`

だったので、stepは`0`から`self.config.total_training_steps-1`の範囲でした。

例えば`total_training_steps`が1,000なら、最後のstepは999となり、`evaluation_frequency`が100であれば、評価対象である100の倍数になりません。

ここで、`for step in range(self.config.total_training_step+1):`にすることで、最後のステップと評価ステップを揃えます。

なお、この方法は`total_training_step`が`evaluation_frequency`の倍数でない場合は成立しないのですが、（例えば`total_training_step`が1050）で`evaluation_frequency`が100とか、通常はそういうことは起きないので気にしなくて大丈夫です。"
"50分くらいで見られるコンテンツとかなんか調べて教えて
世界中の人にとって意味があるやつで"
"import time

class Trainer:
    def __init__(self, model, optimizer, data_loader, config):
        self.model = model
        self.optimizer = optimizer
        self.data_loader = data_loader
        self.config = config

        self.steps = []
        self.train_losses = []
        self.val_losses = []
        ########## NEW ##########
        self.total_seen_tokens_list = []
        self.total_train_time_list = []
        ########## NEW ##########

    def train_step(self):
        # トレーニング用バッチを取得。
        input_batch, target_batch = self.data_loader.get_batch('train')
        self.optimizer.zero_grad()

        # モデルの順伝播と損失計算
        logits, loss = self.model(input_batch, target_batch)
        loss.backward()  # 誤差逆伝播
        self.optimizer.step()  # パラメータ更新

        return loss.item() # 損失の値を返す

    def evaluate(self):
        self.model.eval()  # 評価モードに切り替え
        losses = {""train"": [], ""val"": []} # 学習・検証データ両方の損失を計算
        with torch.no_grad():
            for split in ['train', 'val']:
                for _ in range(self.config.evaluation_loops):
                    input_batch, target_batch = self.data_loader.get_batch(split)
                    _, loss = self.model(input_batch, target_batch)
                    losses[split].append(loss.item())
        self.model.train()  # 再び学習モードへ戻す

        # 各データセット（train, val）での損失の平均を計算して返す
        return {split: sum(values) / len(values) for split, values in losses.items()}

    def train(self):
        # configで指定された回数だけtrain_stepを実行する。
        for step in range(self.config.total_training_steps):
            # 100回ごと、または最終ステップのみ評価する。
            if step % self.config.evaluation_frequency == 0 or step == self.config.total_training_steps - 1:
                # step==0 は last_eval_end_time 未定義のため除外。最終ステップは途中計測になる可能性があるため除外。
                if step == 0 or step == self.config.total_training_steps - 1:
                  tokens_per_second = None
                  ########## NEW ##########
                  # 最初のステップ
                  if step == 0:
                    total_train_time = 0
                  # 最終ステップ
                  else:
                    current_time = time.time()
                    interval_from_last_eval = current_time - last_eval_end_time
                    total_train_time += interval_from_last_eval
                  ########## NEW ##########
                else:
                  current_eval_start_time = time.time()
                  evaluation_interval = current_eval_start_time - last_eval_end_time
                  ########## NEW ##########
                  total_train_time += evaluation_interval
                  ########## NEW ##########
                  tokens_per_evaluation_interval = self.config.batch_size * self.config.input_sequence_length * self.config.evaluation_frequency
                  tokens_per_second = tokens_per_evaluation_interval / evaluation_interval

                eval_loss = self.evaluate()

                ########## NEW ##########
                total_seen_tokens = self.config.batch_size * self.config.input_sequence_length * step
                ########## NEW ##########

                ########## NEW ##########
                print(
                    f""step {step:05d} | ""
                    f""train loss {eval_loss['train']:.4f} | ""
                    f""val loss {eval_loss['val']:.4f} | ""
                    f""tok/s {int(tokens_per_second) if tokens_per_second is not None else 'None'} | ""
                    f""tokens {total_seen_tokens:,} | ""
                    f""time {total_train_time:.2f}s""
                )
                ########## NEW ##########

                self.steps.append(step)
                self.train_losses.append(eval_loss['train'])
                self.val_losses.append(eval_loss['val'])
                ########## NEW ##########
                self.total_seen_tokens_list.append(total_seen_tokens)
                self.total_train_time_list.append(total_train_time)
                ########## NEW ##########

                # この評価が終わった時間を記録する。次の評価開始時との時間差が`evaluation_interval`となる。
                last_eval_end_time = time.time()

            # 1回の学習ステップ（毎回行う主な処理）
            train_loss = self.train_step()


def new_train(self):
    # (configで指定された回数+1)だけtrain_stepを実行する。)
    ########## NEW ##########
    for step in range(self.config.total_training_steps+1):
    ########## NEW ##########
        # 100回ごとに評価する。
        ########## NEW ##########
        if step % self.config.evaluation_frequency == 0:
        ########## NEW ##########

            ########## NEW ##########
            if step == 0:
              tokens_per_second = None
              total_train_time = 0
            ########## NEW ##########
            else:
              current_eval_start_time = time.time()
              evaluation_interval = current_eval_start_time - last_eval_end_time
              total_train_time += evaluation_interval
              tokens_per_evaluation_interval = self.config.batch_size * self.config.input_sequence_length * self.config.evaluation_frequency
              tokens_per_second = tokens_per_evaluation_interval / evaluation_interval

            eval_loss = self.evaluate()
            total_seen_tokens = self.config.batch_size * self.config.input_sequence_length * step
    
            print(
                f""step {step:05d} | ""
                f""train loss {eval_loss['train']:.4f} | ""
                f""val loss {eval_loss['val']:.4f} | ""
                f""tok/s {int(tokens_per_second) if tokens_per_second is not None else 'None'} | ""
                f""tokens {total_seen_tokens:,} | ""
                f""time {total_train_time:.2f}s""
            )
            
            self.steps.append(step)
            self.train_losses.append(eval_loss['train'])
            self.val_losses.append(eval_loss['val'])
            self.total_seen_tokens_list.append(total_seen_tokens)
            self.total_train_time_list.append(total_train_time)

            # この評価が終わった時間を記録する。次の評価開始時との時間差が`evaluation_interval`となる。
            last_eval_end_time = time.time()

        # 1回の学習ステップ（毎回行う主な処理）
        train_loss = self.train_step()"
Adam optimizerを数式で教えて