# 最適復習間隔計算システム
class OptimalReviewScheduler:
def __init__(self):
self.intervals = [1, 3, 7, 14, 30, 60]  # 日数
self.difficulty_multipliers = {
'easy': 1.3,
'medium': 1.0,
'hard': 0.7
}
def calculate_next_review(self, current_interval, difficulty, success_rate):
        """次回復習日程計算"""
base_multiplier = self.difficulty_multipliers[difficulty]
# 成功率に基づく調整
success_multiplier = 0.5 + (success_rate * 0.5)
next_interval = int(current_interval * base_multiplier * success_multiplier)
return min(next_interval, 180)  # 最大6ヶ月
def generate_study_schedule(self, topics, exam_date):
        """学習スケジュール自動生成"""
schedule = {}
for topic in topics:
first_study = datetime.now()
reviews = []
for interval in self.intervals:
review_date = first_study + timedelta(days=interval)
if review_date < exam_date:
reviews.append(review_date)
schedule[topic] = {
'first_study': first_study,
'reviews': reviews,
'estimated_retention': self.calculate_retention_rate(len(reviews))
}
return schedule

class ActiveRecallSystem:
def __init__(self):
self.question_types = [
'definition',
'application',
'comparison',
'troubleshooting',
'best_practice'
]
def generate_recall_questions(self, topic, content):
        """能動的想起用問題生成"""
questions = []
# 定義問題
questions.append({
'type': 'definition',
'question': f"{topic}とは何ですか？主要な特徴を3つ説明してください。",
'difficulty': 'easy'
})
# 応用問題
questions.append({
'type': 'application',
'question': f"{topic}を実際のプロジェクトで使用する場合、どのような手順で実装しますか？",
'difficulty': 'medium'
})
# 比較問題
questions.append({
'type': 'comparison',
'question': f"{topic}と類似技術の違いは何ですか？それぞれの利点・欠点を説明してください。",
'difficulty': 'hard'
})
return questions
def conduct_recall_session(self, questions):
        """想起セッション実行"""
results = []
for question in questions:
start_time = time.time()
# 問題提示（実際の実装では音声やGUI）
print(f"問題: {question['question']}")
# 回答時間測定
user_answer = input("回答: ")
response_time = time.time() - start_time
# 自己評価
confidence = int(input("確信度 (1-5): "))
results.append({
'question_id': question.get('id'),
'response_time': response_time,
'confidence': confidence,
'difficulty': question['difficulty']
})
return results

class LearningStyleOptimizer:
def __init__(self):
self.learning_styles = {
'visual': ['図表', 'マインドマップ', '動画', 'インフォグラフィック'],
'auditory': ['音声講義', 'ディスカッション', '音読', 'ポッドキャスト'],
'kinesthetic': ['実習', 'シミュレーション', '手書きノート', '実機操作'],
'reading': ['テキスト', 'ドキュメント', '要約', 'チェックリスト']
}
def diagnose_learning_style(self, user_responses):
        """学習スタイル診断"""
scores = {style: 0 for style in self.learning_styles.keys()}
# 診断質問の回答を分析
for response in user_responses:
for style, keywords in self.learning_styles.items():
if any(keyword in response.lower() for keyword in keywords):
scores[style] += 1
# 主要学習スタイル特定
primary_style = max(scores, key=scores.get)
secondary_style = sorted(scores.items(), key=lambda x: x[1], reverse=True)[1][0]
return {
'primary': primary_style,
'secondary': secondary_style,
'scores': scores
}
def customize_content_delivery(self, content, learning_style):
        """学習スタイルに応じたコンテンツ最適化"""
optimizations = {
'visual': {
'format': 'infographic',
'elements': ['diagrams', 'flowcharts', 'color_coding'],
'tools': ['mind_mapping', 'visual_notes']
},
'auditory': {
'format': 'audio_explanation',
'elements': ['verbal_examples', 'discussions', 'mnemonics'],
'tools': ['text_to_speech', 'study_groups']
},
'kinesthetic': {
'format': 'hands_on_practice',
'elements': ['labs', 'simulations', 'real_projects'],
'tools': ['virtual_labs', 'practice_environments']
},
'reading': {
'format': 'structured_text',
'elements': ['bullet_points', 'summaries', 'definitions'],
'tools': ['note_taking', 'highlighting']
}
}
return optimizations.get(learning_style['primary'], optimizations['reading'])

class CognitiveLoadManager:
def __init__(self):
self.load_thresholds = {
'intrinsic': 0.7,    # 内在的負荷
'extraneous': 0.2,   # 外在的負荷
'germane': 0.1       # 学習関連負荷
}
def assess_cognitive_load(self, content_complexity, presentation_format, user_expertise):
        """認知負荷評価"""
# 内在的負荷（コンテンツの本質的難易度）
intrinsic_load = self.calculate_intrinsic_load(content_complexity, user_expertise)
# 外在的負荷（提示方法による負荷）
extraneous_load = self.calculate_extraneous_load(presentation_format)
# 学習関連負荷（スキーマ構築に使用される負荷）
germane_load = 1.0 - intrinsic_load - extraneous_load
return {
'intrinsic': intrinsic_load,
'extraneous': extraneous_load,
'germane': max(0, germane_load),
'total': intrinsic_load + extraneous_load,
'optimal': intrinsic_load + extraneous_load <= 0.9
}
def optimize_content_chunking(self, content, max_chunk_size=7):
        """コンテンツの最適チャンク化"""
# ミラーの法則（7±2）に基づくチャンク化
chunks = []
current_chunk = []
for item in content:
if len(current_chunk) < max_chunk_size:
current_chunk.append(item)
else:
chunks.append(current_chunk)
current_chunk = [item]
if current_chunk:
chunks.append(current_chunk)
return chunks
def generate_progressive_disclosure(self, content_chunks):
        """段階的開示システム"""
disclosure_plan = []
for i, chunk in enumerate(content_chunks):
disclosure_plan.append({
'level': i + 1,
'content': chunk,
'prerequisites': disclosure_plan[:i] if i > 0 else [],
'estimated_time': len(chunk) * 2,  # 分
'cognitive_load': self.assess_cognitive_load(
len(chunk), 'structured', 'intermediate'
)
})
return disclosure_plan

class FeynmanLearningMethod:
def __init__(self):
self.explanation_levels = [
'expert',      # 専門用語使用
'intermediate', # 一般的な技術用語
'beginner',    # 日常用語のみ
'child'        # 小学生レベル
]
def conduct_feynman_session(self, topic, target_level='child'):
        """ファインマン学習セッション"""
session_steps = [
self.concept_identification(topic),
self.simple_explanation(topic, target_level),
self.gap_identification(),
self.refinement_and_simplification()
]
results = {}
for step_name, step_func in zip(
['identification', 'explanation', 'gaps', 'refinement'], 
session_steps
):
results[step_name] = step_func
return results
def simple_explanation(self, topic, target_level):
        """シンプル説明生成"""
explanation_templates = {
'child': "{}は、{}のようなものです。例えば、{}",
'beginner': "{}とは{}です。主な特徴は{}で、{}に使用されます。",
'intermediate': "{}は{}の技術で、{}の目的で使用されます。{}との違いは{}です。",
'expert': "{}は{}アーキテクチャにおける{}コンポーネントで、{}を実現します。"
}
template = explanation_templates.get(target_level, explanation_templates['beginner'])
return {
'template': template,
'target_level': target_level,
'complexity_score': self.calculate_complexity_score(template)
}
def gap_identification(self):
        """理解ギャップ特定"""
common_gaps = [
"専門用語を使わずに説明できない",
"具体例を思い浮かべられない", 
"他の概念との関係が不明確",
"実際の使用場面がイメージできない"
]
return {
'potential_gaps': common_gaps,
'assessment_questions': [
"この概念を友人に説明できますか？",
"実際の例を3つ挙げられますか？",
"なぜこの技術が必要なのですか？",
"他の方法と比べて何が優れていますか？"
]
}

import sqlite3
from datetime import datetime, timedelta
import math
class SpacedRepetitionSystem:
def __init__(self, db_path='srs.db'):
self.conn = sqlite3.connect(db_path)
self.setup_database()
# SM-2アルゴリズムパラメータ
self.ease_factor_default = 2.5
self.ease_factor_min = 1.3
self.interval_multiplier = 1.0
def setup_database(self):
        """データベース初期化"""
self.conn.execute('''
            CREATE TABLE IF NOT EXISTS cards (
                id INTEGER PRIMARY KEY,
                topic TEXT NOT NULL,
                question TEXT NOT NULL,
                answer TEXT NOT NULL,
                ease_factor REAL DEFAULT 2.5,
                interval INTEGER DEFAULT 1,
                repetitions INTEGER DEFAULT 0,
                next_review DATE,
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
            )
        ''')
self.conn.execute('''
            CREATE TABLE IF NOT EXISTS reviews (
                id INTEGER PRIMARY KEY,
                card_id INTEGER,
                quality INTEGER,
                response_time REAL,
                reviewed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                FOREIGN KEY (card_id) REFERENCES cards (id)
            )
        ''')
self.conn.commit()
def add_card(self, topic, question, answer):
        """新しいカード追加"""
cursor = self.conn.cursor()
cursor.execute('''
            INSERT INTO cards (topic, question, answer, next_review)
            VALUES (?, ?, ?, ?)
        ''', (topic, question, answer, datetime.now().date()))
self.conn.commit()
return cursor.lastrowid
def get_due_cards(self, limit=20):
        """復習対象カード取得"""
cursor = self.conn.cursor()
cursor.execute('''
            SELECT id, topic, question, answer, ease_factor, interval, repetitions
            FROM cards
            WHERE next_review <= ?
            ORDER BY next_review ASC
            LIMIT ?
        ''', (datetime.now().date(), limit))
return cursor.fetchall()
def process_review(self, card_id, quality, response_time):
        """復習結果処理（SM-2アルゴリズム）"""
# 現在のカード情報取得
cursor = self.conn.cursor()
cursor.execute('''
            SELECT ease_factor, interval, repetitions
            FROM cards WHERE id = ?
        ''', (card_id,))
ease_factor, interval, repetitions = cursor.fetchone()
# SM-2アルゴリズム適用
if quality >= 3:  # 正解
if repetitions == 0:
new_interval = 1
elif repetitions == 1:
new_interval = 6
else:
new_interval = int(interval * ease_factor)
new_repetitions = repetitions + 1
else:  # 不正解
new_interval = 1
new_repetitions = 0
# 難易度係数更新
new_ease_factor = ease_factor + (0.1 - (5 - quality) * (0.08 + (5 - quality) * 0.02))
new_ease_factor = max(new_ease_factor, self.ease_factor_min)
# 次回復習日計算
next_review = datetime.now().date() + timedelta(days=new_interval)
# データベース更新
cursor.execute('''
            UPDATE cards 
            SET ease_factor = ?, interval = ?, repetitions = ?, next_review = ?
            WHERE id = ?
        ''', (new_ease_factor, new_interval, new_repetitions, next_review, card_id))
# 復習履歴記録
cursor.execute('''
            INSERT INTO reviews (card_id, quality, response_time)
            VALUES (?, ?, ?)
        ''', (card_id, quality, response_time))
self.conn.commit()
return {
'next_review': next_review,
'interval': new_interval,
'ease_factor': new_ease_factor
}

import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
class LearningAnalyticsDashboard:
def __init__(self, srs_system):
self.srs = srs_system
def generate_progress_report(self, days=30):
        """学習進捗レポート生成"""
# データ取得
cursor = self.srs.conn.cursor()
cursor.execute('''
            SELECT 
                DATE(reviewed_at) as review_date,
                COUNT(*) as reviews_count,
                AVG(quality) as avg_quality,
                AVG(response_time) as avg_response_time
            FROM reviews
            WHERE reviewed_at >= date('now', '-{} days')
            GROUP BY DATE(reviewed_at)
            ORDER BY review_date
        '''.format(days))
data = cursor.fetchall()
df = pd.DataFrame(data, columns=['date', 'reviews', 'quality', 'response_time'])
# 可視化
fig, axes = plt.subplots(2, 2, figsize=(15, 10))
# 日別復習数
axes[0, 0].plot(df['date'], df['reviews'])
axes[0, 0].set_title('日別復習数')
axes[0, 0].set_xlabel('日付')
axes[0, 0].set_ylabel('復習数')
# 平均品質スコア
axes[0, 1].plot(df['date'], df['quality'], color='green')
axes[0, 1].set_title('平均品質スコア')
axes[0, 1].set_xlabel('日付')
axes[0, 1].set_ylabel('品質スコア')
# 平均応答時間
axes[1, 0].plot(df['date'], df['response_time'], color='orange')
axes[1, 0].set_title('平均応答時間')
axes[1, 0].set_xlabel('日付')
axes[1, 0].set_ylabel('秒')
# 学習効率（品質/時間）
efficiency = df['quality'] / df['response_time']
axes[1, 1].plot(df['date'], efficiency, color='purple')
axes[1, 1].set_title('学習効率')
axes[1, 1].set_xlabel('日付')
axes[1, 1].set_ylabel('効率スコア')
plt.tight_layout()
plt.savefig('learning_progress.png', dpi=300, bbox_inches='tight')
return {
'total_reviews': df['reviews'].sum(),
'avg_quality': df['quality'].mean(),
'avg_response_time': df['response_time'].mean(),
'learning_trend': self.calculate_learning_trend(df)
}
def calculate_retention_rate(self, topic=None):
        """記憶定着率計算"""
query = '''
            SELECT 
                c.topic,
                COUNT(*) as total_reviews,
                SUM(CASE WHEN r.quality >= 3 THEN 1 ELSE 0 END) as successful_reviews,
                AVG(r.quality) as avg_quality
            FROM cards c
            JOIN reviews r ON c.id = r.card_id
        '''
params = []
if topic:
query += ' WHERE c.topic = ?'
params.append(topic)
query += ' GROUP BY c.topic'
cursor = self.srs.conn.cursor()
cursor.execute(query, params)
results = []
for row in cursor.fetchall():
topic_name, total, successful, avg_quality = row
retention_rate = (successful / total) * 100 if total > 0 else 0
results.append({
'topic': topic_name,
'retention_rate': retention_rate,
'total_reviews': total,
'avg_quality': avg_quality
})
return results

class AWSCertificationOptimizer:
def __init__(self):
self.service_categories = {
'compute': ['EC2', 'Lambda', 'ECS', 'EKS'],
'storage': ['S3', 'EBS', 'EFS', 'FSx'],
'database': ['RDS', 'DynamoDB', 'ElastiCache', 'Redshift'],
'networking': ['VPC', 'CloudFront', 'Route53', 'ELB']
}
self.learning_priorities = {
'SAA': ['compute', 'storage', 'networking', 'database'],
'SOA': ['monitoring', 'automation', 'security', 'troubleshooting'],
'SAP': ['architecture', 'migration', 'cost_optimization', 'security']
}
def create_aws_study_plan(self, certification_type, available_hours_per_week):
        """AWS資格別学習計画作成"""
priorities = self.learning_priorities.get(certification_type, [])
total_topics = sum(len(self.service_categories.get(cat, [])) for cat in priorities)
# 週間学習時間配分
hours_per_topic = available_hours_per_week / len(priorities)
study_plan = {}
for week, category in enumerate(priorities, 1):
services = self.service_categories.get(category, [])
study_plan[f'Week_{week}'] = {
'category': category,
'services': services,
'allocated_hours': hours_per_topic,
'learning_objectives': self.get_learning_objectives(category, certification_type),
'practice_labs': self.get_practice_labs(category),
'assessment': self.get_assessment_questions(category)
}
return study_plan
def get_learning_objectives(self, category, cert_type):
        """カテゴリ別学習目標"""
objectives = {
'compute': [
'EC2インスタンスタイプの選択基準を理解する',
'Auto Scalingの設定と最適化ができる',
'Lambdaの使用場面と制限を把握する'
],
'storage': [
'S3ストレージクラスの使い分けができる',
'EBSボリュームタイプの特徴を理解する',
'データライフサイクル管理を設計できる'
]
}
return objectives.get(category, [])