iOS Natural Language Framework Rehberi

1import NaturalLanguage
2 
3class LanguageDetector {
4    private let recognizer = NLLanguageRecognizer()
5 
6    func detectLanguage(text: String) -> String {
7        recognizer.reset()
8        recognizer.processString(text)
9 
10        guard let language = recognizer.dominantLanguage else {
11            return "Bilinmiyor"
12        }
13 
14        return language.rawValue
15    }
16 
17    func detectLanguageWithConfidence(text: String) -> [(NLLanguage, Double)] {
18        recognizer.reset()
19        recognizer.processString(text)
20 
21        // En yuksek 5 olasilik
22        let hypotheses = recognizer.languageHypotheses(withMaximum: 5)
23 
24        return hypotheses.sorted { item1, item2 in
25            item1.value > item2.value
26        }
27    }
28 
29    // Coklu dil tespiti
30    func detectMultipleLanguages(text: String) -> [NLLanguage] {
31        recognizer.reset()
32        recognizer.processString(text)
33 
34        return recognizer.languageHypotheses(withMaximum: 3)
35            .filter { pair in pair.value > 0.1 }
36            .map { pair in pair.key }
37    }
38}
39 
40// Kullanim
41let detector = LanguageDetector()
42let lang = detector.detectLanguage(text: "Merhaba dunya, nasilsiniz?")
43print("Tespit edilen dil: \(lang)") // "tr"

1import NaturalLanguage
2 
3class TextTokenizer {
4    // Kelime bazinda tokenization
5    func tokenizeWords(text: String) -> [String] {
6        let tokenizer = NLTokenizer(unit: .word)
7        tokenizer.string = text
8 
9        var tokens: [String] = []
10        tokenizer.enumerateTokens(in: text.startIndex..<text.endIndex) { range, _ in
11            tokens.append(String(text[range]))
12            return true
13        }
14 
15        return tokens
16    }
17 
18    // Cumle bazinda tokenization
19    func tokenizeSentences(text: String) -> [String] {
20        let tokenizer = NLTokenizer(unit: .sentence)
21        tokenizer.string = text
22 
23        var sentences: [String] = []
24        tokenizer.enumerateTokens(in: text.startIndex..<text.endIndex) { range, _ in
25            sentences.append(String(text[range]))
26            return true
27        }
28 
29        return sentences
30    }
31}
32 
33let tokenizer = TextTokenizer()
34let words = tokenizer.tokenizeWords(text: "Swift ile NLP uygulamasi gelistiriyoruz.")
35print(words) // ["Swift", "ile", "NLP", "uygulamasi", "gelistiriyoruz"]

1import NaturalLanguage
2 
3func lemmatize(text: String) -> [(String, String)] {
4    let tagger = NLTagger(tagSchemes: [.lemma])
5    tagger.string = text
6 
7    var results: [(String, String)] = []
8 
9    tagger.enumerateTags(
10        in: text.startIndex..<text.endIndex,
11        unit: .word,
12        scheme: .lemma
13    ) { tag, range in
14        let word = String(text[range])
15        let lemma = tag?.rawValue ?? word
16        results.append((word, lemma))
17        return true
18    }
19 
20    return results
21}
22 
23let results = lemmatize(text: "The cats were running quickly")
24// [("cats", "cat"), ("were", "be"), ("running", "run"), ("quickly", "quickly")]

1import NaturalLanguage
2 
3struct NamedEntity {
4    let text: String
5    let type: NLTag
6    let range: Range<String.Index>
7}
8 
9func extractEntities(from text: String) -> [NamedEntity] {
10    let tagger = NLTagger(tagSchemes: [.nameType])
11    tagger.string = text
12 
13    let options: NLTagger.Options = [.omitPunctuation, .omitWhitespace]
14    var entities: [NamedEntity] = []
15 
16    tagger.enumerateTags(
17        in: text.startIndex..<text.endIndex,
18        unit: .word,
19        scheme: .nameType,
20        options: options
21    ) { tag, range in
22        if let tag = tag,
23           tag != .otherWord {
24            entities.append(NamedEntity(
25                text: String(text[range]),
26                type: tag,
27                range: range
28            ))
29        }
30        return true
31    }
32 
33    return entities
34}
35 
36// Kullanim
37let entities = extractEntities(from: "Apple CEO Tim Cook San Francisco'da konustu")
38// [("Apple", .organizationName), ("Tim Cook", .personalName), ("San Francisco", .placeName)]

1import NaturalLanguage
2 
3class SentimentAnalyzer {
4    private let tagger = NLTagger(tagSchemes: [.sentimentScore])
5 
6    func analyzeSentiment(text: String) -> Double {
7        tagger.string = text
8 
9        let (tag, _) = tagger.tag(
10            at: text.startIndex,
11            unit: .paragraph,
12            scheme: .sentimentScore
13        )
14 
15        return Double(tag?.rawValue ?? "0") ?? 0.0
16    }
17 
18    func categorizeSentiment(text: String) -> String {
19        let score = analyzeSentiment(text: text)
20 
21        switch score {
22        case 0.5...:
23            return "Cok Pozitif"
24        case 0.1..<0.5:
25            return "Pozitif"
26        case -0.1..<0.1:
27            return "Notr"
28        case -0.5 ..< -0.1:
29            return "Negatif"
30        default:
31            return "Cok Negatif"
32        }
33    }
34}
35 
36let analyzer = SentimentAnalyzer()
37let sentiment = analyzer.categorizeSentiment(text: "Bu urun gercekten harika!")
38print(sentiment) // "Cok Pozitif"

1import NaturalLanguage
2 
3func findSimilarWords(to word: String, count: Int = 5) -> [(String, Double)] {
4    guard let embedding = NLEmbedding.wordEmbedding(for: .english) else {
5        return []
6    }
7 
8    var results: [(String, Double)] = []
9    embedding.enumerateNeighbors(for: word, maximumCount: count) { neighbor, distance in
10        results.append((neighbor, distance))
11        return true
12    }
13 
14    return results
15}
16 
17// "swift" kelimesine benzer kelimeler
18let similar = findSimilarWords(to: "swift")
19// [("fast", 0.3), ("quick", 0.35), ("rapid", 0.4), ...]