firebirdテクテクテクブログ

1
2
3
4
5
6
7
8

❌ 悪い例：
「この関数を最適化して」

✅ 良い例：
「この関数は1秒間に1000回呼び出されるパフォーマンス重要な処理です。
現在の問題：メモリ使用量が多く、レスポンス時間が200ms超過
目標：レスポンス時間50ms以下、メモリ使用量30%削減
制約：既存APIとの互換性維持必須」

1
2
3
4
5
6
7
8
9

❌ 悪い例：
「このエラーを修正して」

✅ 良い例：
「以下のエラーを分析し、修正案を提示してください：
1. エラーの原因分析
2. 修正コード（コメント付き）
3. テストケース例
4. 再発防止策」

1
2
3
4

✅ 効果的な役割設定：
「あなたは10年の経験を持つシニアReact開発者です。
パフォーマンス最適化とアクセシビリティに詳しく、
企業レベルの開発基準を理解しています。」

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# 問題設定：APIレスポンス時間改善
# 目標：平均レスポンス時間50%削減
# 制約：既存機能の完全互換性

# AIとの協働アプローチ
def optimize_api_response():
    """
    AI支援による段階的最適化
    
    Phase 1: ボトルネック特定
    Phase 2: 改善案生成・検証
    Phase 3: 実装・テスト
    """
    
    # AIプロンプト例：
    # 「以下のAPI処理でパフォーマンスボトルネックを特定し、
    # 具体的な改善策を3つ以上提案してください。
    # 各改善策には実装難易度と期待効果を含めてください。」

  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
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

import openai
import whisper
from datetime import datetime
import json

class AIMinutesGenerator:
    def __init__(self):
        self.whisper_model = whisper.load_model("base")
        self.openai_client = openai.OpenAI()
    
    def process_meeting_audio(self, audio_file_path):
        """音声ファイルから議事録を生成"""
        
        # Step 1: 音声認識
        transcript = self.whisper_model.transcribe(audio_file_path)
        raw_text = transcript["text"]
        
        # Step 2: AIによる構造化
        structured_minutes = self.structure_meeting_content(raw_text)
        
        # Step 3: アクションアイテム抽出
        action_items = self.extract_action_items(raw_text)
        
        return {
            "meeting_date": datetime.now().isoformat(),
            "raw_transcript": raw_text,
            "structured_minutes": structured_minutes,
            "action_items": action_items,
            "summary": self.generate_summary(structured_minutes)
        }
    
    def structure_meeting_content(self, text):
        """議事録の構造化"""
        prompt = f"""
        以下の会議音声テキストを読みやすい議事録に整理してください：

        要求事項：
        1. 発言者の特定（可能な範囲で）
        2. 議題ごとの整理
        3. 決定事項の明確化
        4. 質疑応答の整理

        出力形式：
        ## 会議概要
        ## 議題・討議内容
        ## 決定事項
        ## 次回までの課題

        会議テキスト：
        {text}
        """
        
        response = self.openai_client.chat.completions.create(
            model="gpt-4",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.3
        )
        
        return response.choices[0].message.content
    
    def extract_action_items(self, text):
        """アクションアイテムの抽出"""
        prompt = f"""
        以下の会議テキストからアクションアイテムを抽出してください：

        抽出基準：
        - 誰が何をいつまでに行うか明確なもの
        - 次回会議までの宿題・課題
        - 確認が必要な事項

        出力形式（JSON）：
        {{
          "action_items": [
            {{
              "task": "タスク内容",
              "assignee": "担当者",
              "deadline": "期限",
              "priority": "high|medium|low"
            }}
          ]
        }}

        会議テキスト：
        {text[:2000]}  # トークン制限考慮
        """
        
        response = self.openai_client.chat.completions.create(
            model="gpt-4",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.1
        )
        
        try:
            return json.loads(response.choices[0].message.content)
        except json.JSONDecodeError:
            return {"action_items": []}

# 使用例
minutes_generator = AIMinutesGenerator()
result = minutes_generator.process_meeting_audio("meeting_20240815.wav")

# 議事録の自動配信
def send_minutes_notification(minutes_data):
    """Slack/Teams等への自動配信"""
    summary = f"""
    📋 会議議事録が完成しました

    📅 日時: {minutes_data['meeting_date']}
    ✅ 決定事項: {len(minutes_data['action_items']['action_items'])}件のアクション
    
    詳細は添付ファイルをご確認ください。
    """
    # 実際の配信処理...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# レベル1：基本的な質問
「Pythonで素数判定を書いて」

# レベル2：文脈を含む質問
「Pythonで大きな数値の素数判定を効率的に行う関数を書いてください。
パフォーマンスが重要で、10^9程度の数値も扱う想定です。」

# レベル3：メタ情報を含む質問
「あなたは数値計算に特化したシニアPython開発者です。
暗号化ライブラリの一部として使用する素数判定関数を実装してください。

要件：
- 入力：最大64bit整数
- 性能：10^9の数値を1秒以内で判定
- セキュリティ：サイドチャネル攻撃耐性考慮
- 保守性：コメント・テスト充実

実装時の考慮点も含めて説明してください。」

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

プロンプト例：
「以下の問題を段階的に解決してください：

問題：ECサイトの在庫管理システム設計

Step 1: 要件分析
- 必要な機能を列挙
- 技術的制約を整理

Step 2: アーキテクチャ設計
- システム構成図
- データフロー設計

Step 3: 実装計画
- 開発優先順位
- リスク要因の特定

Step 4: 具体的実装
- コア機能のサンプルコード
- テスト戦略

各ステップで判断根拠も含めて説明してください。」

 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

# 1. 環境設定
export OPENAI_API_KEY="your-api-key"

# 2. 基本的な使用法
# コード生成
openai api completions.create \
  -m code-davinci-002 \
  -p "# Python関数：リストの重複を除去" \
  --max-tokens 150

# 3. コード解説・リファクタリング
openai api completions.create \
  -m code-davinci-002 \
  -p "# 以下のコードを解説し、改善点を提案：
$(cat legacy_function.py)" \
  --max-tokens 500

# 4. バッチ処理による効率化
for file in src/*.py; do
  echo "Analyzing $file..."
  openai api completions.create \
    -m code-davinci-002 \
    -p "# コードレビュー：$(cat $file)" \
    --max-tokens 300 > "reviews/$(basename $file).review"
done

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

def choose_ai_assistant(project_type, team_size, budget):
    """AI開発支援ツールの選択ロジック"""
    
    if project_type == "learning":
        return "Replit Ghostwriter"  # 学習に最適
    
    elif project_type == "enterprise":
        if "aws" in tech_stack:
            return "Amazon CodeWhisperer"  # AWS統合
        else:
            return "GitHub Copilot"  # 企業標準
    
    elif project_type == "startup":
        if budget < 1000:
            return "GitHub Copilot"  # コスパ重視
        else:
            return "Cursor"  # 最新機能活用
    
    else:
        return "GitHub Copilot"  # 汎用性重視

 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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

import pandas as pd
import openai

class AIDataAnalyst:
    def __init__(self):
        self.client = openai.OpenAI()
    
    def analyze_dataset(self, df, business_question):
        """AI支援によるデータ分析"""
        
        # Step 1: データ概要の理解
        data_summary = self.generate_data_summary(df)
        
        # Step 2: 分析方針の策定
        analysis_plan = self.create_analysis_plan(data_summary, business_question)
        
        # Step 3: 分析実行
        results = self.execute_analysis(df, analysis_plan)
        
        # Step 4: 洞察の抽出
        insights = self.extract_insights(results, business_question)
        
        return {
            "data_summary": data_summary,
            "analysis_plan": analysis_plan,
            "results": results,
            "insights": insights
        }
    
    def generate_data_summary(self, df):
        """データセットの概要生成"""
        basic_info = {
            "shape": df.shape,
            "columns": df.columns.tolist(),
            "dtypes": df.dtypes.to_dict(),
            "missing_values": df.isnull().sum().to_dict(),
            "basic_stats": df.describe().to_dict()
        }
        
        prompt = f"""
        以下のデータセット情報を分析し、データの特徴を要約してください：
        
        {basic_info}
        
        注目ポイント：
        1. データ品質の評価
        2. 潜在的な分析課題
        3. 推奨される前処理
        """
        
        response = self.client.chat.completions.create(
            model="gpt-4",
            messages=[{"role": "user", "content": prompt}]
        )
        
        return response.choices[0].message.content
    
    def create_analysis_plan(self, data_summary, business_question):
        """分析計画の策定"""
        prompt = f"""
        ビジネス課題：{business_question}
        データ概要：{data_summary}
        
        上記を踏まえ、効果的な分析計画を策定してください：
        
        1. 分析目的の明確化
        2. 必要な前処理手順
        3. 適用すべき分析手法
        4. 期待される成果物
        5. 潜在的なリスク・制約
        """
        
        response = self.client.chat.completions.create(
            model="gpt-4",
            messages=[{"role": "user", "content": prompt}]
        )
        
        return response.choices[0].message.content

# 使用例
analyst = AIDataAnalyst()
sales_data = pd.read_csv("sales_data.csv")
analysis = analyst.analyze_dataset(
    sales_data, 
    "売上向上のための顧客セグメント分析"
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# 悪い指示例
「このコードを直して」

# 良い指示例
「以下のReactコンポーネントについて、パフォーマンスとアクセシビリティの観点から改善してください：

現在の問題：
1. 不要な再レンダリングが発生
2. キーボードナビゲーション未対応
3. スクリーンリーダー対応不十分

改善要求：
1. useMemo/useCallbackによる最適化
2. ARIA属性の適切な設定
3. フォーカス管理の実装
4. 変更点の詳細な説明

対象コード：
[コードを貼り付け]

 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

def generate_tech_article(topic, target_audience, article_type):
    """技術記事の構造化生成"""
    
    prompt = f"""
    技術記事を作成してください：
    
    テーマ: {topic}
    対象読者: {target_audience}
    記事タイプ: {article_type}
    
    構成要求：
    1. 導入（問題提起・背景）
    2. 解決策の提示（具体例含む）
    3. 実装詳細（コード例・設定例）
    4. 注意点・ベストプラクティス
    5. まとめ・今後の展望
    
    記事の特徴：
    - 実践的で即座に使える内容
    - 初心者にも理解しやすい説明
    - 最新の技術動向を反映
    - 具体的なコード例を豊富に含む
    """
    
    # AI生成後の品質チェック
    def validate_article_quality(content):
        checks = {
            "code_examples": "```" in content,
            "structure": all(section in content for section in 
                           ["##", "###", "導入", "まとめ"]),
            "length": len(content) > 2000,
            "practical": any(keyword in content.lower() for keyword in 
                           ["例", "手順", "方法", "実装"])
        }
        return checks

 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

class ReliableAIAssistant:
    def __init__(self):
        self.verification_steps = [
            "fact_checking",
            "code_validation", 
            "logic_verification",
            "source_confirmation"
        ]
    
    def verified_response(self, query, domain="general"):
        """検証済みレスポンスの生成"""
        
        # Step 1: 初期回答生成
        initial_response = self.generate_response(query)
        
        # Step 2: ファクトチェック
        if domain in ["technical", "medical", "legal"]:
            fact_check_result = self.fact_check(initial_response, domain)
            if not fact_check_result.reliable:
                return self.generate_conservative_response(query)
        
        # Step 3: コード検証（技術的内容の場合）
        if self.contains_code(initial_response):
            code_validation = self.validate_code_snippets(initial_response)
            if not code_validation.all_valid:
                initial_response = self.fix_code_issues(initial_response, code_validation)
        
        # Step 4: 信頼度スコア付与
        confidence_score = self.calculate_confidence(initial_response, domain)
        
        return {
            "response": initial_response,
            "confidence": confidence_score,
            "verification_status": "verified" if confidence_score > 0.8 else "uncertain",
            "sources": self.get_supporting_sources(query, domain)
        }
    
    def fact_check(self, content, domain):
        """ドメイン固有のファクトチェック"""
        if domain == "technical":
            return self.check_technical_accuracy(content)
        elif domain == "medical":
            return self.check_medical_claims(content)
        else:
            return self.general_fact_check(content)

 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

import hashlib
from cryptography.fernet import Fernet

class PrivacyPreservingAI:
    def __init__(self):
        self.encryption_key = Fernet.generate_key()
        self.cipher = Fernet(self.encryption_key)
        
    def anonymize_query(self, query):
        """クエリの匿名化処理"""
        
        # 個人情報の検出・マスキング
        pii_patterns = {
            "email": r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b',
            "phone": r'\b\d{3}-\d{4}-\d{4}\b',
            "name": r'\b[A-Z][a-z]+ [A-Z][a-z]+\b'  # 簡易的な名前検出
        }
        
        anonymized_query = query
        for pii_type, pattern in pii_patterns.items():
            anonymized_query = re.sub(pattern, f"[{pii_type.upper()}]", anonymized_query)
        
        return anonymized_query
    
    def secure_ai_interaction(self, user_query):
        """プライバシー保護AI対話"""
        
        # 1. クエリの匿名化
        safe_query = self.anonymize_query(user_query)
        
        # 2. ローカル処理の優先
        if self.can_process_locally(safe_query):
            return self.local_ai_processing(safe_query)
        
        # 3. 暗号化通信
        encrypted_query = self.cipher.encrypt(safe_query.encode())
        response = self.external_ai_api(encrypted_query)
        
        # 4. ログの匿名化
        self.log_interaction(
            query_hash=hashlib.sha256(user_query.encode()).hexdigest()[:8],
            response_type=type(response).__name__,
            timestamp=datetime.now()
        )
        
        return response

 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

import whisper
from PIL import Image
import openai

class MultimodalAIProcessor:
    def __init__(self):
        self.whisper_model = whisper.load_model("base")
        self.openai_client = openai.OpenAI()
    
    def process_multimedia_content(self, image_path, audio_path, text_context):
        """マルチモーダルコンテンツの統合分析"""
        
        # 1. 音声認識
        audio_transcript = self.whisper_model.transcribe(audio_path)
        
        # 2. 画像解析
        image_description = self.analyze_image(image_path)
        
        # 3. 統合分析
        integrated_analysis = self.integrate_multimodal_data(
            text=text_context,
            audio=audio_transcript["text"],
            image=image_description
        )
        
        return integrated_analysis
    
    def analyze_image(self, image_path):
        """GPT-4 Vision による画像分析"""
        with open(image_path, "rb") as image_file:
            base64_image = base64.b64encode(image_file.read()).decode()
        
        response = self.openai_client.chat.completions.create(
            model="gpt-4-vision-preview",
            messages=[{
                "role": "user",
                "content": [
                    {"type": "text", "text": "この画像の内容を詳しく説明してください"},
                    {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_image}"}}
                ]
            }]
        )
        
        return response.choices[0].message.content

 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
54
55
56

// TensorFlow.js による軽量AI実装
import * as tf from '@tensorflow/tfjs';

class EdgeAIProcessor {
  constructor() {
    this.model = null;
    this.isInitialized = false;
  }
  
  async initialize() {
    try {
      // 軽量なMobileNetモデルをロード
      this.model = await tf.loadLayersModel('/models/lightweight-nlp.json');
      this.isInitialized = true;
      console.log('Edge AI model loaded successfully');
    } catch (error) {
      console.error('Failed to load AI model:', error);
    }
  }
  
  async processTextLocally(text) {
    if (!this.isInitialized) {
      await this.initialize();
    }
    
    // テキストの前処理
    const tokenized = this.tokenizeText(text);
    const tensor = tf.tensor2d([tokenized]);
    
    // ローカル推論実行
    const prediction = this.model.predict(tensor);
    const result = await prediction.data();
    
    // メモリクリーンアップ
    tensor.dispose();
    prediction.dispose();
    
    return {
      sentiment: result[0] > 0.5 ? 'positive' : 'negative',
      confidence: Math.abs(result[0] - 0.5) * 2,
      processedLocally: true
    };
  }
  
  tokenizeText(text) {
    // 簡易的なトークン化
    return text.toLowerCase()
      .split(' ')
      .slice(0, 100) // 最大100トークン
      .map(word => this.vocabulary[word] || 0);
  }
}

// 使用例
const edgeAI = new EdgeAIProcessor();
const result = await edgeAI.processTextLocally("This is a great product!");

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

# AI/ML開発環境
pip install openai whisper transformers torch

# データ処理・分析
pip install pandas numpy matplotlib seaborn plotly

# 音声・画像処理
pip install librosa pillow opencv-python

# Web開発・API
pip install fastapi uvicorn streamlit gradio

# 品質保証・テスト
pip install pytest pytest-mock responses