[iOS] CoreData

アプリを閉じても Core Data に保存される（永続化）

Xcode で新しいプロジェクトを作るときに
「Use Core Data」にチェックを入れます ☑️
これで自動的に以下が追加されます：
YourAppName.xcdatamodeld（データモデル）
Persistence.swift

ステップ 2：データモデルを定義
YourAppName.xcdatamodeld を開いて「＋」を押し、
新しい Entity を作成します：

Entity 名：Memo
Attribute：
text（String）
timestamp（Date）

import SwiftUI
import CoreData

struct ContentView: View {
    // Core Data の管理オブジェクトコンテキスト
    @Environment(\.managedObjectContext) private var viewContext

    // 保存済みメモを取得して監視
    @FetchRequest(
        sortDescriptors: [NSSortDescriptor(keyPath: \Memo.timestamp, ascending: false)],
        animation: .default)
    private var memos: FetchedResults<Memo>

    @State private var newMemo: String = ""

    var body: some View {
        NavigationView {
            VStack(spacing: 20) {
                // メモ入力欄
                TextField("メモを入力", text: $newMemo)
                    .textFieldStyle(RoundedBorderTextFieldStyle())
                    .padding(.horizontal)

                // 保存ボタン
                Button(action: addMemo) {
                    Label("保存", systemImage: "square.and.arrow.down")
                }
                .buttonStyle(.borderedProminent)

                Divider()

                // メモ一覧
                List {
                    ForEach(memos) { memo in
                        VStack(alignment: .leading, spacing: 4) {
                            Text(memo.text ?? "")
                                .font(.headline)
                            if let date = memo.timestamp {
                                Text(date, style: .date)
                                    .font(.caption)
                                    .foregroundColor(.gray)
                            }
                        }
                    }
                    .onDelete(perform: deleteMemos)
                }
                .listStyle(.inset)

                Spacer()
            }
            .navigationTitle("メモ帳")
            .toolbar {
                EditButton()
            }
        }
    }

    // MARK: - Core Data 操作

    /// メモを追加
    private func addMemo() {
        guard !newMemo.isEmpty else { return }
        let memo = Memo(context: viewContext)
        memo.text = newMemo
        memo.timestamp = Date()

        do {
            try viewContext.save()
            newMemo = ""
        } catch {
            print("💥 保存エラー: \(error.localizedDescription)")
        }
    }

    /// メモを削除
    private func deleteMemos(at offsets: IndexSet) {
        for index in offsets {
            let memo = memos[index]
            viewContext.delete(memo)
        }

        do {
            try viewContext.save()
        } catch {
            print("💥 削除エラー: \(error.localizedDescription)")
        }
    }
}

// MARK: - プレビュー用

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        // プレビューでも Core Data のコンテキストを注入
        let context = PersistenceController.preview.container.viewContext
        ContentView()
            .environment(\.managedObjectContext, context)
    }
}

CoreDataの概念はわかったが、ソースの実行がうまくいかん..

[LLM] LoRA / PEFT(軽量ファインチューニング)

### ファインチューニング（fine-tuning） とは?
すでに学習済みのLLM（例：LLaMA, GPT, Mistralなど）を
自分のデータで「再訓練」して、特定の用途に特化させること。

e.g.
ChatGPTを「医療専門AI」にしたい
LLaMAを「企業マニュアルの質問回答AI」にしたい
Mistralを「社内チャットボット」に最適化したい

### why it need fine tuning
LLMは汎用的なので、例えば次のような弱点があります。

通常のLLM チューニング後
「契約書の条文っぽい文章」を知らない 法律文体で出力できる
「企業内の独自用語」を知らない 社内専門語で答える
指定フォーマットを守らない JSON形式で必ず回答する

### LoRA / PEFTとは？（軽量ファインチューニング）
通常のファインチューニングは、
巨大モデル全体を再学習するため、
GPU・時間・コストが非常に高くつきます（数十GB〜数百GB）。
→ そこで登場したのが LoRA や PEFT。

🔹 LoRA（Low-Rank Adaptation）
LoRAは、「モデル全体ではなく一部の重みだけを微調整」する仕組みです。
📘 ざっくり言うと：
「LLM本体は凍結（変更しない）」
「一部の行列（重み）だけを低次元（rank低い）で学習」

これにより👇
項目 通常ファインチューニング LoRA
学習パラメータ数 数百億 数百万（1〜3%）
必要GPUメモリ 数百GB 数GB
コスト 非常に高い 低コスト
再利用 不可（モデルごと） 可能（LoRA層だけ切り替え可）

元の重み W に、小さな変化 ΔW を足してチューニングする。
ΔW = A × B （A,Bは小さい行列＝低ランク）

🔹 PEFT（Parameter-Efficient Fine-Tuning）
LoRAを含む「軽量ファインチューニング技術の総称」です。
PEFTには以下のような手法があります：

手法 概要
LoRA 一部の重みを低ランクで更新
Prefix Tuning プロンプトに「学習したベクトル」を前置
Prompt Tuning 入力部分だけ学習（モデル本体は凍結）
Adapter Tuning モデルの中間層に追加ネットワークを挿入
➡️ Hugging Face の peft ライブラリ はこれらを統一的に扱えます。

from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import LoraConfig, get_peft_model

# ベースモデル
model_name = "meta-llama/Llama-2-7b-hf"
model = AutoModelForCausalLM.from_pretrained(model_name)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# LoRA設定
lora_config = LoraConfig(
    r=8,               # rank（低次元のサイズ）
    lora_alpha=16,     # 学習率スケーリング
    target_modules=["q_proj", "v_proj"],  # attention層だけチューニング
    lora_dropout=0.05,
)

# LoRAモデルを作成
model = get_peft_model(model, lora_config)

# 学習用データ（例）
texts = [
    {"input": "会社の理念を説明してください。", "output": "私たちは顧客の信頼を第一とします。"},
]

# トークナイズと学習処理（実際はTrainerを使用）
# model.fit(...)

# 学習済みLoRAを保存（ベースモデルと分離）
model.save_pretrained("my_lora_adapter/")

[Dify LLM] PythonでDifyのworkflowに入力して出力を取得する

import requests
import json
import os

from dotenv import load_dotenv
load_dotenv()

API_KEY = os.environ.get("DIFY_API_KEY")
APP_ID = os.environ.get("APP_ID")

BASE_URL = "https://api.dify.ai/v1" 
CHAT_ENDPOINT = f"{BASE_URL}/chat-messages"

user_input = "おはようございます。"

payload = {
    # ユーザーからのメインの質問（ワークフローの {{query}} に対応）
    "query": user_input,
    
    # ワークフロー内の他の入力ノードに渡す変数（オプション）
    "inputs": {
        # 例: ワークフロー内の変数名が 'context' の場合、ここで値を渡せる
        "context": "Null" 
    },
    
    # ユーザーIDは必須（セッション管理用）。適当なUUIDなどを指定
    "user": "user_python_script_001", 
    
    # ストリーミングを無効にする
    "response_mode": "blocking", 
}

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

try:
    # --- API呼び出し ---
    response = requests.post(
        CHAT_ENDPOINT,
        headers=headers,
        data=json.dumps(payload)
    )
    
    response.raise_for_status() # HTTPエラーが発生した場合に例外を発生させる
    data = response.json()

    # --- 出力の取得 ---
    if data and 'answer' in data:
        print("✅ ワークフローの出力 (回答):")
        print(data['answer'])
    else:
        print("⚠️ ワークフローからの回答が見つかりません。")
        print(data)

except requests.exceptions.HTTPError as errh:
    print(f"HTTP エラーが発生しました: {errh}")
    print(response.text)
except requests.exceptions.RequestException as err:
    print(f"リクエスト中にエラーが発生しました: {err}")

$ python3 dify-llm.py
✅ ワークフローの出力 (回答):
おはようございます。今日は何のお手伝いができますか？

アプリ（iOS/Android）から直接Difyを呼び出すのではなく、バックエンドサーバー（Python）を経由させて、そのサーバーでTTS（Text-to-Speech、音声合成）処理を行ってからアプリに返す構成の方が、より一般的で推奨されている。

なるほど、Dify APIの理解度が一気に高まった。

[Django] Template View

urls.py

from django.contrib import admin
from django.urls import path
from .views import helloworldfunc, HelloWorldClass

urlpatterns = [
    path('admin/', admin.site.urls),
    path('helloworldurl/', helloworldfunc),
    path('helloworldurl2/', HelloWorldClass.as_view()),
]

views.py

from django.http import HttpResponse
from django.views.generic import TemplateView 

def helloworldfunc(request):
    return HttpResponse("<h1>Hello, World!</h1>")

class HelloWorldClass(TemplateView):
    template_name = "hello.html"

settings.py

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [BASE_DIR / 'templates'],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

[Figma] 画面遷移の設定

① 画面（Frame）を2つ作る
② ボタンを置く
③ Prototypeモードに切り替える
④ 画面をつなぐ

Designの中にフレームが一つだけでしたが、複数フレームを置いて、Prototypeモードで繋げるのですね。なるほど！

[android]UIのアニメーション Composeのanimate*関数で滑らかなUI体験

MainActivity.kt は「アプリの起動エントリポイント（＝最初に表示される画面）」を定義する場所
UI（画面の中身）はComposable関数として別ファイルに分けて定義 するのが一般的

package com.example.zeus

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.animation.core.animateDpAsState
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.material3.Button
import androidx.compose.material3.Text
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContent {
            AnimatedBoxDemo()
        }
    }
}

@Composable
fun AnimatedBoxDemo() {
    var expanded by remember { mutableStateOf(false) }

    val boxSize by animateDpAsState(
        targetValue = if (expanded) 200.dp else 100.dp,
        label = "box animation"
    )

    Column(
        modifier = Modifier
            .fillMaxSize()
            .padding(16.dp),
        horizontalAlignment = Alignment.CenterHorizontally,
        verticalArrangement = Arrangement.Center
    ) {
        Box(
            modifier = Modifier
                .size(boxSize)
                .background(Color(0xFF4CAF50))
        )

        Spacer(modifier = Modifier.height(24.dp))

        Button(onClick = { expanded = !expanded }) {
            Text(if (expanded) "縮小" else "拡大")
        }
    }
}

byはプロパティデリゲーション（Property Delegation）というkotlin独特の記法で任せるという書き方。

[LLM] RAG（検索拡張生成）

RAG（Retrieval-Augmented Generation／検索拡張生成）は、LLMの「記憶の弱点」を補うための仕組み

### RAGの基本アイディア
– 学習データが古い
– 企業固有の情報を知らない
– 事実を正確に記憶していない

### RAGの仕組み（流れ）
1. ユーザーの質問（Query）

2. 検索（Retrieval）
・質問を ベクトル化（embedding） して数値化
・ベクトルデータベース（例：FAISS, Chroma, Milvusなど）から
・「意味的に近い文書」を検索

3. 統合（Augmentation）
検索で得たテキストをまとめて「プロンプトに埋め込む」

以下の資料を参考に質問に答えてください：
[資料1: ...]
[資料2: ...]
質問：2025年の日本の経済成長率は？

4. 生成（Generation）
LLMがその検索結果（コンテキスト）をもとに回答を生成

ユーザー質問
↓
【Embedding】→ ベクトル化
↓
【Vector DB】→ 意味的に近い文書を検索
↓
【Augmentation】→ 文書をプロンプトに追加
↓
【LLM生成】→ 文脈に基づいて回答生成

### デメリット
– 検索精度が悪いと、間違った情報を引用してしまう
– ベクトルDBの管理・更新が必要
– 長いコンテキストを扱うとコストが増える

from openai import OpenAI
import faiss
import numpy as np

client = OpenAI(api_key="sk-***")

docs = ["富士山は日本で一番高い山です", "日本の首都は東京です"]
embs = [client.embeddings.create(model="text-embedding-3-small", input=d).data[0].embedding for d in docs]


index = faiss.IndexFlatL2(len(embs[0]))
index.add(np.array(embs))

query = "日本の一番高い山は？"
q_emb = client.embeddings.create(model="text-embedding-3-small", input=query).data[0].embedding

D, I = index.search(np.array([q_emb]), k=1)
context = docs[I[0][0]]

prompt = f"次の情報を参考に質問に答えてください。\n資料: {context}\n質問: {query}"
resp = client.responses.create(model="gpt-4o-mini", input=prompt)

print(resp.output_text)

$ python3 rag.py
日本の一番高い山は富士山です。

FAISSとPostgreSQLの違い
観点 FAISS PostgreSQL（psql）
開発元 Meta（旧Facebook） PostgreSQL Global Development Group
主な用途 ベクトル検索（類似度検索） 構造化データの検索・管理
データの種類 数値ベクトル（例：768次元の埋め込み） テーブル形式（行・列）
検索内容 「意味的に似ている文章や画像を探す」 「条件に一致する行を探す（例：WHERE句）」
検索方法 コサイン類似度 / 内積 / L2距離 SQL文（SELECT, JOIN, ORDER BYなど）
速度 超高速（数百万ベクトルでもミリ秒単位） 適度（構造化クエリに最適）
保存形式 メモリ上のインデックス（永続化も可） 永続的なデータベースファイル
例 「この文に似た文を探せ」 「age > 30 のユーザーを取得」

なるほど、FAISSはmetaが開発しているのね。

[LLM] 3Blue1BrownのLLM解説

3Blue1Brown は有名なYoutubeチャンネル
https://www.youtube.com/@3blue1brown

制作者：Grant Sanderson（グラント・サンダーソン）
内容：数学・AI・物理などの抽象的な概念を超美しいアニメーションで可視化する教育チャンネル
名前の意味：制作者の目の色（片方が青3つ、もう片方が茶1つ）に由来しています

■高品質なアニメーション
使用しているツールは Manim（Mathematical Animation Engine）
自作のPythonライブラリで、数学アニメーション専用。
現在はオープンソース化され、教育・AI研究の可視化に広く使われています。
👉 Manim公式

OpenAIやDeepMindのエンジニアも「彼の動画で理解した」と発言

### 3Blue1BrownのLLM解説
1. LLMとは「次の単語を予測する関数」
LLM（大規模言語モデル）は、あるテキストの直後に続く単語を予測する確率分布関数と考えられる。
ただし「最も確率の高い単語」を常に選ぶわけではなく、ランダム性を持たせて応答を自然にするよう設計されることがある。
モデルは、与えられた文脈（プロンプト＋生成済みテキスト）をすべて使って次の単語を決定する。

2. Transformer／Attention の利用
3Blue1Brown の解説では、LLM内部で Transformer（Attention 機構） が使われている点を詳細に描写します。
– Embed（埋め込み）段階：単語を高次元ベクトルに変換
– Attention：各単語ベクトルが他の単語ベクトルに注目して情報を交換
– Feed Forward ネットワーク（MLP）：Attention 後のベクトルを各位置で独立変換
– これらの処理を複数層重ねることで、文脈の情報が多段階で取り込まれていく

3. 事実の記憶（Knowledge / Facts の “格納”）
3Blue1Brown は “LLM がどうやって事実（知識）を内部に持つか” という観点に触れています。特に “How might LLMs store facts” という章で詳述。
– モデルの MLP（多層パーセプトロン）層 に、事実情報がある程度蓄えられている可能性を指摘
– 例示：入力「Michael Jordan plays the sport of ___」に対して “basketball” を予測できるのは、内部で “Michael Jordan → basketball” という対応を何らかのベクトル操作で実現しているから、という説明
3blue1brown.com
+1
– この観点から、「Attention は文脈処理／結合、MLP は知識格納の役割を持つ」という分担感が描かれています

4. モデルの規模と訓練の難しさ
3Blue1Brown では、LLM の巨大さ・計算コストにも触れています。
3blue1brown.com
何十億〜何千億というパラメータ（重み）を持つ
それらを最適化するための学習には膨大なデータと計算資源が必要
人間が株ごとパラメータを設定するわけではなく、勾配法 + 損失関数 によって徐々に学ばれる

5. 応答の確率的性・多様性
3Blue1Brown は「同じプロンプトでも違う応答が返る」点にも言及します。
3blue1brown.com
モデルは確率分布を使って次の単語を選ぶので、必ずしも最頻出語を返すわけではない
少し確率が下がる語を選ぶことで、応答が自然・人間らしくなる

[LLM] Hugging Face の「Transformers」入門

### Hugging Faceとは
AIモデル（特にLLM）を「共有・利用・学習」できるオープンソースのAIプラットフォームです。
– GitHubのように世界中の研究者・企業がモデルを公開
– 代表ライブラリが「transformers」
– 無料で多くのモデルをダウンロードして使える

### transformers ライブラリの目的
transformers は 最先端のNLPモデルを簡単に使うためのPythonライブラリ。
代表的な利用例：
– 文章生成（GPT, LLaMA）
– 翻訳（Marian, T5）
– 要約（BART）
– 感情分析（BERT）
– 質問応答（DistilBERT）

### 基本の3構成
1️⃣ Tokenizer（トークナイザー）
→ テキストを数値化（単語 → トークンID）
2️⃣ Model（モデル）
→ トークン列を処理して出力を返す
3️⃣ Pipeline（パイプライン）
→ Tokenizer と Model をまとめて簡単に使える便利関数

実際のコード例

from transformers import pipeline
# 感情分析のパイプラインをロード
classifier = pipeline("sentiment-analysis")
# テキストを入力
result = classifier("I love Hugging Face!")
print(result)
# [{'label': 'POSITIVE', 'score': 0.9998}]

モデルを指定したコード

from transformers import AutoTokenizer, AutoModelForCausalLM

model_name = "gpt2"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

input_text = "Hello, my name is"
inputs = tokenizer(input_text, return_tensors="pt")

outputs = model.generate(**inputs, max_length=20)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

主なpipeline
感情分析 pipeline(“sentiment-analysis”) 映画レビューなど
翻訳 pipeline(“translation”, model=”Helsinki-NLP/opus-mt-en-jp”) 英→日翻訳
要約 pipeline(“summarization”) ニュース要約
文章生成 pipeline(“text-generation”, model=”gpt2″) GPT風応答
質問応答 pipeline(“question-answering”) QAボット

注意点
– モデルサイズが大きい場合、ダウンロードに時間がかかる
– GPUがあると高速（CUDA対応）
– オフライン実行も可能（cache_dirを指定）

[LLM] Attention is All You Need

Attention is All You Need

従来の機械翻訳（Seq2Seq）はこうでした：
🧩 RNN（LSTMなど）で入力文を順に読み、隠れ状態にエンコード
🧩 その状態をデコーダーが順に展開して出力を生成
→ つまり「時系列処理（順番に読む）」が前提。
しかしRNNは並列化できず、長文では文脈を忘れやすいという弱点がありました。

Transformerの発想
「全部並列で読んで、Attention（注意機構）で関係性だけを学習すればいい」
つまり：
時系列構造をやめて「全単語を同時に見て」
単語間の関係を Attention で表現する
→ これがタイトルの “Attention is All You Need” の意味です。

構成は「エンコーダ」と「デコーダ」の2ブロック：
ブロック 役割 構成
Encoder 入力文の意味を圧縮・表現 Self-Attention + Feed Forward
Decoder その表現をもとに出力文を生成 Masked Self-Attention + Cross-Attention + Feed Forward

名前 役割
Q (Query) 注目する視点（どの単語に注目したいか）
K (Key) 単語の特徴（注目される側）
V (Value) 実際に取り出す情報

🎭 Multi-Head Attentionとは？
「1つの視点では足りない」ので、
複数の異なるQ, K, V空間（ヘッド） を並列で使い、
さまざまな関係（文法的・意味的など）を学びます。

Feed Forward Network（FFN）
Self-Attentionの出力（各単語）を、
個別に2層のMLP（全結合層）で変換します。
これにより非線形変換が入り、表現力が上がります。