Eğitimde Yapay Zeka Uygulamaları

import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.cluster import KMeans
import tensorflow as tf
from tensorflow.keras import layers

class AdaptiveLearningSystem:
    def __init__(self):
        self.student_model = None
        self.content_difficulty_model = None
        self.learning_style_clusters = None

    def analyze_student_profile(self, student_data):
        """
        Öğrenci performans analizi ve profil oluşturma
        """
        profile = {
            'student_id': student_data['student_id'],
            'learning_pace': self._calculate_learning_pace(student_data),
            'mastery_levels': self._calculate_mastery(student_data),
            'learning_style': self._determine_learning_style(student_data),
            'engagement_score': self._calculate_engagement(student_data),
            'struggle_areas': self._identify_struggles(student_data),
            'strengths': self._identify_strengths(student_data)
        }

        return profile

    def _calculate_learning_pace(self, data):
        """
        Öğrenme hızı analizi
        """
        # Soruları tamamlama süreleri
        completion_times = data['question_completion_times']
        avg_time = np.mean(completion_times)

        # Başarı oranı
        accuracy = data['correct_answers'] / data['total_questions']

        # Hız-doğruluk dengesi
        if avg_time < 30 and accuracy > 0.8:
            pace = 'Fast Learner'
        elif avg_time < 60 and accuracy > 0.7:
            pace = 'Normal'
        elif avg_time > 90 or accuracy < 0.5:
            pace = 'Needs Support'
        else:
            pace = 'Steady'

        return {
            'pace': pace,
            'avg_completion_time': avg_time,
            'accuracy': accuracy
        }

    def _calculate_mastery(self, data):
        """
        Konu bazlı hakimiyet seviyeleri
        """
        mastery = {}

        for topic in data['topics']:
            topic_questions = data[data['topic'] == topic]

            # Son 10 soru performansı
            recent_accuracy = topic_questions.tail(10)['correct'].mean()

            # Süre içinde gelişim
            improvement = self._calculate_improvement(topic_questions)

            if recent_accuracy >= 0.9:
                level = 'Mastered'
            elif recent_accuracy >= 0.7:
                level = 'Proficient'
            elif recent_accuracy >= 0.5:
                level = 'Developing'
            else:
                level = 'Beginner'

            mastery[topic] = {
                'level': level,
                'accuracy': recent_accuracy,
                'improvement_rate': improvement
            }

        return mastery

    def _determine_learning_style(self, data):
        """
        Öğrenme stili tespiti (görsel, işitsel, kinestetik)
        """
        preferences = {
            'video_completion_rate': data['video_completions'] / data['video_starts'],
            'text_time_spent': data['reading_time_minutes'],
            'interactive_engagement': data['interactive_exercises_completed'],
            'quiz_preference': data['quiz_attempts'] / data['total_activities']
        }

        # En yüksek engagement türü
        if preferences['video_completion_rate'] > 0.8:
            style = 'Visual (Görsel)'
        elif preferences['text_time_spent'] > 30:
            style = 'Reading/Writing (Okuma/Yazma)'
        elif preferences['interactive_engagement'] > 20:
            style = 'Kinesthetic (Kinestetik)'
        else:
            style = 'Mixed (Karma)'

        return style

    def _calculate_engagement(self, data):
        """
        Engagement skoru (0-100)
        """
        factors = {
            'login_frequency': min(data['logins_per_week'] / 7, 1) * 25,
            'time_on_platform': min(data['minutes_per_week'] / 300, 1) * 25,
            'completion_rate': data['completed_activities'] / data['assigned_activities'] * 25,
            'proactive_learning': min(data['voluntary_activities'] / 10, 1) * 25
        }

        total_score = sum(factors.values())
        return {
            'total': total_score,
            'breakdown': factors,
            'level': 'High' if total_score > 75 else 'Medium' if total_score > 50 else 'Low'
        }

    def recommend_next_content(self, student_profile, available_content):
        """
        Öğrenci profiline göre sonraki içerik önerisi
        """
        recommendations = []

        for content in available_content:
            score = self._score_content(student_profile, content)
            recommendations.append({
                'content_id': content['id'],
                'title': content['title'],
                'topic': content['topic'],
                'difficulty': content['difficulty'],
                'type': content['type'],  # video, quiz, reading, interactive
                'match_score': score,
                'reasoning': self._explain_recommendation(student_profile, content, score)
            })

        # Sırala ve en iyi 5'i döndür
        recommendations.sort(key=lambda x: x['match_score'], reverse=True)
        return recommendations[:5]

    def _score_content(self, profile, content):
        """
        İçerik-öğrenci uyum skoru
        """
        score = 0

        # Zorluk seviyesi uyumu
        mastery = profile['mastery_levels'].get(content['topic'], {})
        current_level = mastery.get('level', 'Beginner')

        difficulty_match = {
            'Beginner': {'Easy': 1.0, 'Medium': 0.3, 'Hard': 0.1},
            'Developing': {'Easy': 0.5, 'Medium': 1.0, 'Hard': 0.4},
            'Proficient': {'Easy': 0.2, 'Medium': 0.7, 'Hard': 1.0},
            'Mastered': {'Easy': 0.1, 'Medium': 0.3, 'Hard': 1.0}
        }

        score += difficulty_match.get(current_level, {}).get(content['difficulty'], 0.5) * 40

        # Öğrenme stili uyumu
        style_preference = {
            'Visual (Görsel)': {'video': 1.0, 'interactive': 0.8, 'reading': 0.5, 'quiz': 0.6},
            'Reading/Writing (Okuma/Yazma)': {'reading': 1.0, 'quiz': 0.8, 'video': 0.5, 'interactive': 0.6},
            'Kinesthetic (Kinestetik)': {'interactive': 1.0, 'quiz': 0.7, 'video': 0.6, 'reading': 0.4}
        }

        style = profile['learning_style']
        score += style_preference.get(style, {}).get(content['type'], 0.5) * 30

        # Önceki performans
        if content['topic'] in profile['struggle_areas']:
            score += 20  # Zayıf konulara öncelik
        elif content['topic'] in profile['strengths']:
            score += 10  # Güçlü konularda ilerleme

        return score

    def _explain_recommendation(self, profile, content, score):
        """
        Öneri açıklaması oluştur
        """
        reasons = []

        mastery = profile['mastery_levels'].get(content['topic'], {})
        if mastery.get('level') == 'Developing':
            reasons.append(f"{content['topic']} konusunda gelişim aşamasındasınız")

        if content['type'] == 'video' and profile['learning_style'] == 'Visual (Görsel)':
            reasons.append("Görsel öğrenme stilinize uygun video içerik")

        if content['topic'] in profile['struggle_areas']:
            reasons.append("Zorlandığınız bir konuda pekiştirme")

        return '; '.join(reasons)

# Deep Learning ile Soru Zorluk Tahmini
class QuestionDifficultyPredictor:
    def __init__(self):
        self.model = self.build_model()

    def build_model(self):
        """
        BERT benzeri model ile soru analizi
        """
        model = tf.keras.Sequential([
            layers.Embedding(input_dim=10000, output_dim=128),
            layers.Bidirectional(layers.LSTM(64, return_sequences=True)),
            layers.Bidirectional(layers.LSTM(32)),
            layers.Dense(64, activation='relu'),
            layers.Dropout(0.3),
            layers.Dense(32, activation='relu'),
            layers.Dense(3, activation='softmax')  # Easy, Medium, Hard
        ])

        model.compile(
            optimizer='adam',
            loss='categorical_crossentropy',
            metrics=['accuracy']
        )

        return model

    def predict_difficulty(self, question_text, answer_options):
        """
        Soru metninden zorluk tahmini
        """
        # Özellik çıkarma
        features = {
            'word_count': len(question_text.split()),
            'avg_word_length': np.mean([len(w) for w in question_text.split()]),
            'has_numbers': any(char.isdigit() for char in question_text),
            'num_options': len(answer_options),
            'question_complexity': self._calculate_complexity(question_text)
        }

        # Model tahmini (simplified)
        difficulties = ['Easy', 'Medium', 'Hard']
        predicted_difficulty = np.random.choice(difficulties)  # Gerçekte model.predict()

        return {
            'difficulty': predicted_difficulty,
            'confidence': 0.85,
            'features': features
        }

    def _calculate_complexity(self, text):
        """
        Metin karmaşıklığı (Flesch-Kincaid benzeri)
        """
        words = text.split()
        sentences = text.count('.') + text.count('?') + 1
        syllables = sum([self._count_syllables(word) for word in words])

        # Flesch Reading Ease
        if len(words) > 0 and sentences > 0:
            fre = 206.835 - 1.015 * (len(words) / sentences) - 84.6 * (syllables / len(words))
        else:
            fre = 100

        if fre > 80:
            return 'Simple'
        elif fre > 60:
            return 'Moderate'
        else:
            return 'Complex'

    def _count_syllables(self, word):
        """
        Hece sayısı tahmini
        """
        vowels = 'aeıioöuü'
        count = sum(1 for char in word.lower() if char in vowels)
        return max(1, count)

# Kullanım
adaptive_system = AdaptiveLearningSystem()

student_data = {
    'student_id': 12345,
    'question_completion_times': [45, 38, 52, 41, 55],
    'correct_answers': 38,
    'total_questions': 50,
    'topics': ['Matematik', 'Fizik', 'Kimya'],
    # ... diğer veriler
}

profile = adaptive_system.analyze_student_profile(student_data)
print(f"Öğrenme Hızı: {profile['learning_pace']['pace']}")
print(f"Öğrenme Stili: {profile['learning_style']}")
print(f"Engagement: {profile['engagement_score']['level']}")

from openai import OpenAI
import spacy
from textblob import TextBlob

class AutomatedGrading:
    def __init__(self):
        self.openai = OpenAI(api_key='your-api-key')
        self.nlp = spacy.load('en_core_web_sm')

    async def grade_essay(self, essay_text, rubric, max_score=100):
        """
        Kompozisyon/makale otomatik değerlendirme
        """
        # GPT-4 ile içerik değerlendirme
        content_analysis = await self._analyze_content(essay_text, rubric)

        # Gramer ve yazım kontrolü
        grammar_score = self._check_grammar(essay_text)

        # Yapı analizi
        structure_score = self._analyze_structure(essay_text)

        # Kelime zenginliği
        vocabulary_score = self._analyze_vocabulary(essay_text)

        # Toplam skor
        total_score = (
            content_analysis['score'] * 0.5 +
            grammar_score * 0.2 +
            structure_score * 0.15 +
            vocabulary_score * 0.15
        )

        feedback = {
            'total_score': round(total_score, 1),
            'grade': self._score_to_grade(total_score),
            'breakdown': {
                'content': content_analysis['score'],
                'grammar': grammar_score,
                'structure': structure_score,
                'vocabulary': vocabulary_score
            },
            'strengths': content_analysis['strengths'],
            'improvements': content_analysis['improvements'],
            'detailed_feedback': content_analysis['feedback']
        }

        return feedback

    async def _analyze_content(self, essay, rubric):
        """
        GPT-4 ile içerik analizi
        """
        prompt = f```Aşağıdaki kompozisyonu değerlendir:

Rubric:
{rubric}

Kompozisyon:
{essay}

Lütfen şunları değerlendir:
1. Ana fikir ve tez netliği
2. Argüman gücü ve kanıt kullanımı
3. Konu hakimiyeti
4. Kritik düşünme
5. Sonuç etkililiği

100 üzerinden puan ver ve detaylı geri bildirim sun.```

        response = await self.openai.chat.completions.create(
            model='gpt-4',
            messages=[
                {
                    'role': 'system',
                    'content': 'Sen deneyimli bir öğretmensin. Yapıcı ve detaylı geri bildirim veriyorsun.'
                },
                {
                    'role': 'user',
                    'content': prompt
                }
            ],
            temperature=0.3
        )

        # AI yanıtını parse et
        analysis = self._parse_gpt_response(response.choices[0].message.content)

        return analysis

    def _check_grammar(self, text):
        """
        Gramer ve yazım kontrolü
        """
        blob = TextBlob(text)

        # Spelling errors
        misspelled = len([word for word in blob.words if word != word.correct()])

        # Sentence structure
        doc = self.nlp(text)
        sentences = list(doc.sents)

        # Gramer skorlama
        grammar_score = 100

        # Her 100 kelimede 1 yazım hatası = -5 puan
        words_count = len(blob.words)
        grammar_score -= (misspelled / words_count * 100) * 5

        # Çok kısa veya çok uzun cümleler
        avg_sentence_length = words_count / len(sentences)
        if avg_sentence_length < 10 or avg_sentence_length > 30:
            grammar_score -= 10

        return max(0, grammar_score)

    def _analyze_structure(self, text):
        """
        Metin yapısı analizi
        """
        doc = self.nlp(text)
        sentences = list(doc.sents)
        paragraphs = text.split('\n\n')

        structure_score = 100

        # Paragraf sayısı kontrolü (en az 3)
        if len(paragraphs) < 3:
            structure_score -= 20

        # Giriş-gelişme-sonuç
        if len(paragraphs) >= 3:
            # İlk paragraf kısa ise (giriş olmalı)
            intro_words = len(paragraphs[0].split())
            if intro_words < 30 or intro_words > 100:
                structure_score -= 10

        # Cümle çeşitliliği
        sentence_lengths = [len(list(sent)) for sent in sentences]
        if len(set(sentence_lengths)) < len(sentence_lengths) * 0.5:
            structure_score -= 10  # Monoton yapı

        return max(0, structure_score)

    def _analyze_vocabulary(self, text):
        """
        Kelime zenginliği analizi
        """
        doc = self.nlp(text)
        words = [token.text.lower() for token in doc if token.is_alpha]

        # Unique word ratio
        unique_ratio = len(set(words)) / len(words)

        # Akademik kelime kullanımı
        academic_words = ['however', 'therefore', 'moreover', 'furthermore', 'consequently']
        academic_count = sum(1 for word in words if word in academic_words)

        vocabulary_score = unique_ratio * 70 + min(academic_count * 3, 30)

        return min(100, vocabulary_score)

    def _score_to_grade(self, score):
        """
        Numerik skordan harf notu
        """
        if score >= 90:
            return 'A'
        elif score >= 80:
            return 'B'
        elif score >= 70:
            return 'C'
        elif score >= 60:
            return 'D'
        else:
            return 'F'

# Matematik Soru Otomatik Puanlama
class MathGrading:
    def grade_math_solution(self, student_answer, correct_answer, show_work=None):
        """
        Matematik sorusu değerlendirme
        """
        result = {
            'correct': False,
            'points': 0,
            'max_points': 10,
            'feedback': []
        }

        # Cevap kontrolü
        if self._normalize_answer(student_answer) == self._normalize_answer(correct_answer):
            result['correct'] = True
            result['points'] = 10
            result['feedback'].append('Doğru cevap! ✓')
        else:
            # Kısmi puan analizi (show_work varsa)
            if show_work:
                partial_credit = self._analyze_work_shown(show_work, correct_answer)
                result['points'] = partial_credit['points']
                result['feedback'].extend(partial_credit['feedback'])
            else:
                result['feedback'].append('Yanlış cevap. İşlem adımlarınızı gösterin.')

        return result

    def _normalize_answer(self, answer):
        """
        Cevabı normalize et (farklı formatları karşılaştırmak için)
        """
        # Boşlukları kaldır, küçük harfe çevir
        normalized = str(answer).strip().lower().replace(' ', '')
        return normalized

    def _analyze_work_shown(self, work, correct_answer):
        """
        Gösterilen işlem adımlarını analiz et
        """
        # Basitleştirilmiş analiz
        # Gerçekte sympy veya başka matematik kütüphaneleri kullanılır

        feedback = []
        points = 0

        if 'x=' in work or '=' in work:
            points += 2
            feedback.append('İşlem adımları gösterilmiş (+2 puan)')

        # Daha detaylı analiz...

        return {'points': points, 'feedback': feedback}

// Node.js - AI Tutor Chatbot
const { OpenAI } = require('openai');

class AITutor {
  constructor(subject = 'Matematik') {
    this.openai = new OpenAI({
      apiKey: process.env.OPENAI_API_KEY
    });
    this.subject = subject;
    this.conversationHistory = [];
  }

  async chat(studentQuestion, studentLevel = 'lise') {
    const systemPrompt = `Sen ${this.subject} konusunda uzman bir öğretmensin.

Öğrenci Seviyesi: ${studentLevel}

Öğretim Prensiplerin:
1. Socratic method kullan - doğrudan cevap verme, düşünmeye yönlendir
2. Adım adım açıkla
3. Örneklerle pekiştir
4. Kavramsal anlayış öncelikli
5. Pozitif ve teşvik edici ol
6. Öğrenci seviyesine uygun dil kullan

Format:
- Açıklamaları basit tut
- Emoji kullan (🎯, ✅, 💡)
- Kısa, anlaşılır cümleler
- Görsel/diyagram önerin (gerekirse)`;

    this.conversationHistory.push({
      role: 'user',
      content: studentQuestion
    });

    const response = await this.openai.chat.completions.create({
      model: 'gpt-4',
      messages: [
        { role: 'system', content: systemPrompt },
        ...this.conversationHistory
      ],
      functions: [
        {
          name: 'generate_practice_question',
          description: 'Konuyla ilgili pratik sorusu oluştur',
          parameters: {
            type: 'object',
            properties: {
              question: { type: 'string' },
              difficulty: { type: 'string', enum: ['kolay', 'orta', 'zor'] },
              hint: { type: 'string' }
            }
          }
        },
        {
          name: 'check_understanding',
          description: 'Öğrencinin anlayışını kontrol et',
          parameters: {
            type: 'object',
            properties: {
              concept: { type: 'string' },
              check_question: { type: 'string' }
            }
          }
        }
      ],
      function_call: 'auto',
      temperature: 0.7
    });

    const assistantMessage = response.choices[0].message;
    this.conversationHistory.push(assistantMessage);

    // Function call varsa işle
    if (assistantMessage.function_call) {
      return this.handleFunctionCall(assistantMessage.function_call);
    }

    return {
      response: assistantMessage.content,
      conversationId: this.conversationHistory.length
    };
  }

  handleFunctionCall(functionCall) {
    const functionName = functionCall.name;
    const args = JSON.parse(functionCall.arguments);

    if (functionName === 'generate_practice_question') {
      return {
        type: 'practice_question',
        question: args.question,
        difficulty: args.difficulty,
        hint: args.hint
      };
    }

    if (functionName === 'check_understanding') {
      return {
        type: 'understanding_check',
        concept: args.concept,
        question: args.check_question
      };
    }
  }

  async generateQuiz(topic, numQuestions = 5) {
    const prompt = `${topic} konusunda ${numQuestions} soruluk quiz oluştur.

Her soru için:
- Soru metni
- 4 şık (A, B, C, D)
- Doğru cevap
- Açıklama

Format: JSON`;

    const response = await this.openai.chat.completions.create({
      model: 'gpt-4',
      messages: [
        { role: 'system', content: 'Quiz oluşturma asistanısın.' },
        { role: 'user', content: prompt }
      ],
      response_format: { type: 'json_object' }
    });

    const quiz = JSON.parse(response.choices[0].message.content);
    return quiz;
  }
}

module.exports = AITutor;