AI-Powered iOS Uygulama Ozellikleri

1import NaturalLanguage
2import CoreML
3 
4class SmartSearchEngine {
5    private let embedding: NLEmbedding?
6    private let tagger: NLTagger
7    private var searchIndex: [(String, [Double])] = []
8 
9    init() {
10        self.embedding = NLEmbedding.wordEmbedding(for: .turkish)
11        self.tagger = NLTagger(tagSchemes: [.lemma, .nameType])
12    }
13 
14    // Icerik indexleme
15    func indexContent(_ items: [SearchableItem]) {
16        searchIndex = items.compactMap { item in
17            guard let vector = computeDocumentVector(item.text) else {
18                return nil
19            }
20            return (item.id, vector)
21        }
22    }
23 
24    // Semantik arama
25    func search(query: String, limit: Int = 10) -> [SearchResult] {
26        // 1. Query'yi lemmatize et
27        let lemmatized = lemmatize(query)
28 
29        // 2. Query vektorunu hesapla
30        guard let queryVector = computeDocumentVector(lemmatized) else {
31            return []
32        }
33 
34        // 3. Cosine similarity ile siralama
35        var results: [SearchResult] = searchIndex.compactMap { (id, docVector) in
36            let similarity = cosineSimilarity(queryVector, docVector)
37            return SearchResult(id: id, score: similarity)
38        }
39 
40        results.sort { $0.score > $1.score }
41        return Array(results.prefix(limit))
42    }
43 
44    private func computeDocumentVector(_ text: String) -> [Double]? {
45        guard let embedding = embedding else { return nil }
46 
47        let tokenizer = NLTokenizer(unit: .word)
48        tokenizer.string = text
49 
50        var vectors: [[Double]] = []
51        tokenizer.enumerateTokens(in: text.startIndex..<text.endIndex) { range, _ in
52            let word = String(text[range]).lowercased()
53            if let vector = embedding.vector(for: word) {
54                vectors.append(vector.map { Double($0) })
55            }
56            return true
57        }
58 
59        guard !vectors.isEmpty else { return nil }
60 
61        // Ortalama vektor
62        let dim = vectors[0].count
63        var avgVector = [Double](repeating: 0, count: dim)
64        for vector in vectors {
65            for i in 0..<dim {
66                avgVector[i] += vector[i]
67            }
68        }
69        let count = Double(vectors.count)
70        return avgVector.map { $0 / count }
71    }
72 
73    private func cosineSimilarity(_ a: [Double], _ b: [Double]) -> Double {
74        guard a.count == b.count else { return 0 }
75        var dot = 0.0, normA = 0.0, normB = 0.0
76        for i in 0..<a.count {
77            dot += a[i] * b[i]
78            normA += a[i] * a[i]
79            normB += b[i] * b[i]
80        }
81        let denom = sqrt(normA) * sqrt(normB)
82        return denom > 0 ? dot / denom : 0
83    }
84 
85    private func lemmatize(_ text: String) -> String {
86        tagger.string = text
87        var lemmas: [String] = []
88        tagger.enumerateTags(
89            in: text.startIndex..<text.endIndex,
90            unit: .word,
91            scheme: .lemma
92        ) { tag, range in
93            lemmas.append(tag?.rawValue ?? String(text[range]))
94            return true
95        }
96        return lemmas.joined(separator: " ")
97    }
98}
99 
100struct SearchableItem {
101    let id: String
102    let text: String
103}
104 
105struct SearchResult {
106    let id: String
107    let score: Double
108}

1import Vision
2import CoreImage
3 
4class SmartPhotoEditor {
5 
6    // Goruntu analizi - sahne, yuz, metin tespiti
7    func analyzeImage(_ image: CGImage) async throws -> ImageAnalysis {
8        // Paralel olarak birden fazla analiz
9        async let faces = detectFaces(image)
10        async let texts = detectText(image)
11        async let saliency = detectSaliency(image)
12 
13        return try await ImageAnalysis(
14            faceCount: faces.count,
15            hasText: !texts.isEmpty,
16            saliencyMap: saliency,
17            suggestedCrop: computeSmartCrop(saliency: saliency)
18        )
19    }
20 
21    private func detectFaces(_ image: CGImage) async throws -> [VNFaceObservation] {
22        let request = VNDetectFaceRectanglesRequest()
23        let handler = VNImageRequestHandler(cgImage: image)
24        try handler.perform([request])
25        return request.results ?? []
26    }
27 
28    private func detectText(_ image: CGImage) async throws -> [VNRecognizedTextObservation] {
29        let request = VNRecognizeTextRequest()
30        request.recognitionLevel = .fast
31        let handler = VNImageRequestHandler(cgImage: image)
32        try handler.perform([request])
33        return request.results ?? []
34    }
35 
36    private func detectSaliency(_ image: CGImage) async throws -> VNSaliencyImageObservation? {
37        let request = VNGenerateAttentionBasedSaliencyImageRequest()
38        let handler = VNImageRequestHandler(cgImage: image)
39        try handler.perform([request])
40        return request.results?.first
41    }
42 
43    private func computeSmartCrop(saliency: VNSaliencyImageObservation?) -> CGRect {
44        guard let saliency = saliency,
45              let salientObject = saliency.salientObjects?.first else {
46            return CGRect(x: 0.1, y: 0.1, width: 0.8, height: 0.8)
47        }
48        return salientObject.boundingBox
49    }
50}
51 
52struct ImageAnalysis {
53    let faceCount: Int
54    let hasText: Bool
55    let saliencyMap: VNSaliencyImageObservation?
56    let suggestedCrop: CGRect
57}

1import Speech
2 
3class SpeechRecognizer: ObservableObject {
4    private let speechRecognizer: SFSpeechRecognizer?
5    private var recognitionRequest: SFSpeechAudioBufferRecognitionRequest?
6    private var recognitionTask: SFSpeechRecognitionTask?
7    private let audioEngine = AVAudioEngine()
8 
9    @Published var transcribedText = ""
10    @Published var isRecording = false
11 
12    init() {
13        speechRecognizer = SFSpeechRecognizer(locale: Locale(identifier: "tr-TR"))
14    }
15 
16    func startRecording() throws {
17        // Onceki task'i iptal et
18        recognitionTask?.cancel()
19        recognitionTask = nil
20 
21        let audioSession = AVAudioSession.sharedInstance()
22        try audioSession.setCategory(.record, mode: .measurement, options: .duckOthers)
23        try audioSession.setActive(true, options: .notifyOthersOnDeactivation)
24 
25        recognitionRequest = SFSpeechAudioBufferRecognitionRequest()
26 
27        guard let recognitionRequest = recognitionRequest,
28              let speechRecognizer = speechRecognizer else {
29            return
30        }
31 
32        recognitionRequest.shouldReportPartialResults = true
33 
34        // On-device tanima (iOS 13+)
35        if speechRecognizer.supportsOnDeviceRecognition {
36            recognitionRequest.requiresOnDeviceRecognition = true
37        }
38 
39        recognitionTask = speechRecognizer.recognitionTask(
40            with: recognitionRequest
41        ) { [weak self] result, error in
42            if let result = result {
43                self?.transcribedText = result.bestTranscription.formattedString
44            }
45 
46            if error != nil || (result?.isFinal ?? false) {
47                self?.stopRecording()
48            }
49        }
50 
51        let inputNode = audioEngine.inputNode
52        let recordingFormat = inputNode.outputFormat(forBus: 0)
53 
54        inputNode.installTap(onBus: 0, bufferSize: 1024, format: recordingFormat) {
55            [weak self] buffer, _ in
56            self?.recognitionRequest?.append(buffer)
57        }
58 
59        audioEngine.prepare()
60        try audioEngine.start()
61        isRecording = true
62    }
63 
64    func stopRecording() {
65        audioEngine.stop()
66        audioEngine.inputNode.removeTap(onBus: 0)
67        recognitionRequest?.endAudio()
68        recognitionRequest = nil
69        recognitionTask = nil
70        isRecording = false
71    }
72}