TensorFlow Başlangıç Rehberi: 7 Adımda Kapsamlı [2026]

2026 yılında yapay zeka ve makine öğrenimi, her sektörde dönüştürücü bir güç olmaya devam ediyor. Bu devrimin kalbinde yer alan TensorFlow gibi platformlar, geliştiricilere ve DevOps mühendislerine eşsiz yetenekler sunuyor. Ancak, bu güçlü araçlara ilk adımı atmak bazen göz korkutucu olabilir. Endişelenmeyin! Bu kapsamlı rehber, TensorFlow'un 2026 itibarıyla en güncel sürümünü kullanarak sıfırdan başlayıp ilk projenizi hayata geçirmeniz için size adım adım yol gösterecek. Bu yazıyı tamamladığınızda, TensorFlow ekosistemine sağlam bir giriş yapmış, temel kavramları anlamış ve kendi modellerinizi oluşturmaya hazır olacaksınız. ## TensorFlow Nedir? TensorFlow, Google tarafından geliştirilen açık kaynaklı, uçtan uca bir makine öğrenimi platformudur. Geliştiricilerin ve araştırmacıların makine öğrenimi modellerini kolayca oluşturmasına, eğitmesine ve dağıtmasına olanak tanır. Özellikle büyük ölçekli veri işleme ve karmaşık sinir ağları için optimize edilmiştir, 2026'da hala sektör lideridir. TensorFlow, verileri çok boyutlu diziler veya "tensörler" olarak temsil eden bir kütüphanedir. Bu tensörler üzerinde çeşitli matematiksel işlemler gerçekleştirerek makine öğrenimi modelleri oluşturulur. Esnek mimarisi sayesinde CPU'lar, GPU'lar ve TPU'lar gibi farklı donanım platformlarında çalışabilir. Hem araştırma hem de üretim ortamlarında yaygın olarak kullanılan TensorFlow, derin öğrenme, doğal dil işleme, bilgisayar görüşü ve diğer birçok yapay zeka uygulamasının temelini oluşturur. 2026'da bile, geniş ekosistemi ve aktif topluluğuyla makine öğrenimi dünyasının vazgeçilmez araçlarından biridir. ## Neden TensorFlow Kullanmalısınız? 2026 yılında makine öğrenimi dünyasına adım atarken veya mevcut projelerinizi ölçeklendirirken TensorFlow'u tercih etmeniz için birçok geçerli neden bulunmaktadır. Bir DevOps mühendisi olarak, bir platformun sadece model geliştirme yeteneklerine değil, aynı zamanda dağıtım, ölçeklenebilirlik ve entegrasyon kolaylığına da dikkat etmeniz gerekir. İşte TensorFlow'un öne çıkan avantajları: * **Ölçeklenebilirlik ve Esneklik:** TensorFlow, küçük projelerden büyük ölçekli kurumsal çözümlere kadar geniş bir yelpazede kullanılabilir. Dağıtık eğitim (distributed training) stratejileri sayesinde, birden fazla GPU veya TPU üzerinde modellerinizi paralel olarak eğitebilirsiniz. Bu, özellikle 2026'daki büyük veri setleri ve karmaşık modeller için kritik bir özelliktir. * **Geniş Ekosistem ve Araçlar:** TensorFlow, Keras API'si ile hızlı prototipleme imkanı sunarken, düşük seviyeli API'lerle de detaylı kontrol sağlar. TensorFlow Extended (TFX) ile MLOps süreçlerini otomatikleştirebilir, TensorFlow.js ile tarayıcıda ML modelleri çalıştırabilir ve TensorFlow Lite ile mobil/gömülü cihazlara dağıtım yapabilirsiniz. Bu entegre ekosistem, DevOps süreçlerini büyük ölçüde kolaylaştırır. * **Aktif ve Büyük Topluluk:** Google tarafından desteklenmesinin yanı sıra, dünya genelinde milyonlarca geliştirici ve araştırmacı tarafından kullanılan aktif bir topluluğa sahiptir. Bu, karşılaştığınız sorunlara hızlıca çözüm bulabileceğiniz, kaynaklara kolayca erişebileceğiniz ve sürekli güncel kalan bir platformda çalıştığınız anlamına gelir. 2026'da Stack Overflow ve GitHub'daki aktivitesi bunun en büyük kanıtıdır. * **Üretim Ortamı Desteği:** TensorFlow Serving, modellerinizi üretim ortamında yüksek performansla sunmanız için tasarlanmıştır. Bu, modellerin REST veya gRPC API'leri aracılığıyla kolayca erişilebilir olmasını sağlar, bu da DevOps ekipleri için dağıtım ve yönetim süreçlerini basitleştirir. Kendi projelerimde, özellikle yüksek trafikli API'lerde TensorFlow Serving'in sağladığı kararlılık ve performans artışlarını defalarca deneyimledim. * **Çapraz Platform Desteği:** Windows, Linux, macOS işletim sistemlerinde, mobil cihazlarda (Android, iOS) ve web tarayıcılarında çalışabilir. Bu esneklik, modellerinizi farklı platformlarda dağıtmanız gerektiğinde büyük avantaj sağlar. **Kimler İçin Uygundur?** TensorFlow, veri bilimcileri, makine öğrenimi mühendisleri, derin öğrenme araştırmacıları ve MLOps süreçlerini otomatikleştirmek isteyen DevOps mühendisleri için idealdir. Özellikle büyük ölçekli ve karmaşık projelerde, dağıtık sistemlerde ve üretim ortamında güvenilir performans arayanlar için vazgeçilmez bir araçtır. **Kimler İçin Uygun Değildir?** Eğer çok küçük, basit bir model geliştirecek ve hızlı bir şekilde prototipleme yapacaksanız, daha hafif kütüphaneler veya daha az karmaşık framework'ler (örneğin Scikit-learn) başlangıç için daha uygun olabilir. Ancak, projenizin büyüme potansiyeli varsa, TensorFlow'a geçiş yapmak uzun vadede size fayda sağlayacaktır. ## TensorFlow vs Alternatifler (2026 Karşılaştırması) Makine öğrenimi dünyasında TensorFlow tek seçenek değildir. PyTorch ve JAX gibi güçlü alternatifler de mevcuttur. 2026 itibarıyla bu üç framework'ün temel özelliklerini karşılaştıralım: | Özellik | TensorFlow (2.x/3.x) | PyTorch (2.x/3.x) | JAX (0.4.x) | | :----------------- | :----------------------------------------------------- | :-------------------------------------------------------- | :--------------------------------------------------------- | | **Geliştiren** | Google | Facebook (Meta) AI | Google (DeepMind) | | **Programlama Dili** | Python, C++, JavaScript | Python, C++ | Python | | **API Seviyesi** | Keras (yüksek), düşük seviyeli API'ler | Sezgisel, Pythonic, dinamik hesap grafiği | NumPy tabanlı, JIT derleme, otomatik farklılaşma | | **Performans** | Optimize edilmiş, dağıtık eğitimde güçlü | Yüksek performans, dinamik grafikle esneklik | XLA ile yüksek performans, araştırma odaklı | | **Öğrenme Eğrisi** | Keras ile kolay, düşük seviyeli API'lerle orta-yüksek | Pythonic yapısı sayesinde nispeten daha kolay | NumPy bilenler için kolay, derin ML için orta-yüksek | | **Ekosistem** | TFX, TF Serving, TF Lite, TF.js (Geniş) | TorchServe, PyTorch Mobile, ONNX (Geniş ve büyüyor) | Flax, Haiku, Optax (Gelişmekte olan) | | **Topluluk** | Çok büyük, kurumsal ve akademik | Çok büyük, akademik ve araştırma odaklı | Büyüyen, araştırma ve Google dahili kullanım odaklı | | **Kurumsal Destek**| Güçlü (Google) | Güçlü (Meta) | Orta (Google DeepMind) | | **Kullanım Alanı** | Üretim, büyük ölçekli dağıtım, araştırma | Araştırma, hızlı prototipleme, bazı üretim ortamları | Yüksek performanslı hesaplama, araştırma, yeni nesil ML | **Yorum:** 2026 itibarıyla TensorFlow, özellikle üretim ortamı dağıtımı ve MLOps entegrasyonu konusunda hala liderliğini sürdürmektedir. PyTorch ise araştırma ve hızlı prototipleme için tercih edilirken, JAX yeni nesil ML araştırmaları ve yüksek performanslı bilimsel hesaplamalar için giderek daha fazla ilgi görmektedir. Seçiminiz projenizin gereksinimlerine, ekibinizin deneyimine ve dağıtım hedeflerinize bağlı olacaktır. ## Kurulum ve İlk Adımlar (2026) TensorFlow'u 2026 yılında kurmak oldukça basittir. En güncel ve kararlı sürümü kurarak başlayacağız. Kurulum için Python 3.9 veya üzeri bir sürüm kullanmanızı şiddetle tavsiye ederim. Ayrıca, bağımlılıkları izole etmek için sanal bir ortam (virtual environment) kullanmak en iyi pratiktir. ### Ön Gereksinimler: * **Python:** 3.9, 3.10 veya 3.11 (2026 itibarıyla stabil ve uyumlu sürümler) * **pip:** Python paket yöneticisi * **venv (önerilir):** Sanal ortam oluşturmak için ### Adım 1: Sanal Ortam Oluşturma Her zaman projeniz için izole bir ortam oluşturun. Bu, bağımlılık çakışmalarını önler ve projenizi taşınabilir hale getirir. ```bash # Yeni bir sanal ortam oluşturun python3 -m venv tf_env_2026 # Sanal ortamı etkinleştirin (Linux/macOS) source tf_env_2026/bin/activate # Sanal ortamı etkinleştirin (Windows CMD) tf_env_2026\Scripts\activate.bat # Sanal ortamı etkinleştirin (Windows PowerShell) tf_env_2026\Scripts\Activate.ps1 ``` ### Adım 2: TensorFlow Kurulumu Sanal ortam etkinleştirildikten sonra, TensorFlow'un en güncel kararlı sürümünü (2026 itibarıyla 2.x veya 3.x serisinden) pip ile kurabiliriz. Eğer GPU desteği istiyorsanız, sisteminizde NVIDIA CUDA ve cuDNN'in kurulu olduğundan emin olmalısınız. Aksi takdirde, CPU sürümü otomatik olarak kurulacaktır. ```bash # TensorFlow'un en güncel CPU sürümünü kurun pip install tensorflow # Eğer GPU desteği ile kurmak istiyorsanız (CUDA/cuDNN kurulu olmalı) # pip install tensorflow[and-cuda] # Kurulumun başarılı olduğunu kontrol edin pip show tensorflow ``` > **Pro Tip:** 2026'da `tensorflow[and-cuda]` paketi, çoğu GPU bağımlılığını otomatik olarak yönetmektedir. Ancak yine de NVIDIA sürücülerinizin güncel olduğundan emin olun. ### Adım 3: Kurulumu Doğrulama Kurulumun doğru yapıldığından emin olmak için basit bir Python betiği çalıştıralım. ```python import tensorflow as tf print(f"TensorFlow Sürümü: {tf.__version__}") print(f"Kullanılabilir GPU'lar: {tf.config.list_physical_devices('GPU')}") # Basit bir tensör işlemi hello_tensor = tf.constant('Merhaba TensorFlow 2026!') print(hello_tensor.numpy().decode('utf-8')) ``` Çıktıda TensorFlow sürümünü ve eğer varsa kullanılabilir GPU'ları görmelisiniz. `Merhaba TensorFlow 2026!` çıktısı da her şeyin yolunda olduğunu gösterir. ## Temel Kullanım ve Örnekler TensorFlow kurulumunu tamamladığımıza göre, şimdi bazı temel kavramları ve kullanım örneklerini inceleyelim. Bu bölümde, TensorFlow'un nasıl çalıştığını anlamanıza yardımcı olacak pratik kod örnekleri sunacağım. Tüm bu örnekler 2026 yılında geçerli olan `tf.keras` API'sini kullanmaktadır. ### Örnek 1: Basit Bir Lineer Regresyon Modeli **Problem:** Basit bir doğrusal ilişkiyi öğrenmek. Örneğin, `y = 2x + 1` denklemini modellemek. **Çözüm:** Küçük bir sinir ağı oluşturup yapay veri üzerinde eğiterek bu ilişkiyi tahmin etmesini sağlayacağız. ```python import tensorflow as tf import numpy as np # 1. Veri Oluşturma X = np.array([0.0, 1.0, 2.0, 3.0, 4.0, 5.0], dtype=float) y = np.array([1.0, 3.0, 5.0, 7.0, 9.0, 11.0], dtype=float) # y = 2x + 1 # 2. Modeli Tanımlama (Keras Sequential API) model = tf.keras.Sequential([ tf.keras.layers.Dense(units=1, input_shape=[1]) ]) # 3. Modeli Derleme model.compile(optimizer='sgd', loss='mean_squared_error') # 4. Modeli Eğitme print("\nModel Eğitimi Başlıyor...") history = model.fit(X, y, epochs=500, verbose=0) print("Model Eğitimi Tamamlandı.") # 5. Tahmin Yapma print(f"\n5.0 için tahmin: {model.predict([5.0])[0][0]:.2f}") # Beklenen: 11.0 print(f"10.0 için tahmin: {model.predict([10.0])[0][0]:.2f}") # Beklenen: 21.0 # Modelin ağırlıklarını (katsayıları) ve biasını göster print(f"Model Ağırlığı (W): {model.get_weights()[0][0][0]:.2f}") print(f"Model Biası (b): {model.get_weights()[1][0]:.2f}") ``` ### Örnek 2: MNIST ile Görüntü Sınıflandırma (Küçük Bir CNN) **Problem:** El yazısı rakamları (0-9) sınıflandırmak. **Çözüm:** Convolutional Neural Network (CNN) kullanarak MNIST veri setini eğiteceğiz. ```python import tensorflow as tf # 1. Veri Setini Yükle ve Hazırla mnist = tf.keras.datasets.mnist (x_train, y_train), (x_test, y_test) = mnist.load_data() x_train, x_test = x_train / 255.0, x_test / 255.0 # CNN için giriş boyutunu yeniden şekillendir x_train = x_train[..., tf.newaxis].astype("float32") x_test = x_test[..., tf.newaxis].astype("float32") # 2. Modeli Tanımlama (Basit CNN) model = tf.keras.models.Sequential([ tf.keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)), tf.keras.layers.MaxPooling2D((2, 2)), tf.keras.layers.Flatten(), tf.keras.layers.Dense(128, activation='relu'), tf.keras.layers.Dropout(0.2), tf.keras.layers.Dense(10, activation='softmax') ]) # 3. Modeli Derleme model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) # 4. Modeli Eğitme print("\nMNIST Modeli Eğitimi Başlıyor...") model.fit(x_train, y_train, epochs=5) print("MNIST Modeli Eğitimi Tamamlandı.") # 5. Modeli Değerlendirme print("\nModel Değerlendirme:") model.evaluate(x_test, y_test, verbose=2) ``` ### Örnek 3: SavedModel Formatında Model Kaydetme ve Yükleme **Problem:** Eğitilmiş bir modeli daha sonra kullanmak veya dağıtmak. **Çözüm:** `tf.keras.models.save_model` ve `tf.keras.models.load_model` fonksiyonlarını kullanacağız. ```python import tensorflow as tf import os # Önceki örnekteki eğitilmiş modeli kullanacağız (varsayalım ki eğitildi) # model = ... (Örnek 2'deki gibi model oluştur ve eğit) # Basit bir model oluşturalım ve eğitelim (eğer Örnek 2 çalıştırılmadıysa) model = tf.keras.Sequential([ tf.keras.layers.Dense(units=1, input_shape=[1]) ]) model.compile(optimizer='sgd', loss='mean_squared_error') model.fit(np.array([0.0, 1.0]), np.array([1.0, 3.0]), epochs=10, verbose=0) # Modeli SavedModel formatında kaydet saved_model_path = os.path.join(os.getcwd(), "my_saved_model_2026") tf.keras.models.save_model(model, saved_model_path) print(f"Model '{saved_model_path}' konumuna kaydedildi.") # Kaydedilen modeli yükle loaded_model = tf.keras.models.load_model(saved_model_path) print(f"Model '{saved_model_path}' konumundan yüklendi.") # Yüklenen model ile tahmin yap print(f"Yüklenen model ile 5.0 için tahmin: {loaded_model.predict([5.0])[0][0]:.2f}") ``` ### Örnek 4: TensorFlow Data API (tf.data) Kullanımı **Problem:** Büyük veri setlerini verimli bir şekilde yüklemek ve işlemek. **Çözüm:** `tf.data` API'sini kullanarak veri pipeline'ı oluşturmak. ```python import tensorflow as tf import numpy as np # Yapay veri oluştur features = np.random.rand(100, 10).astype(np.float32) labels = np.random.randint(0, 2, size=100).astype(np.int32) # tf.data.Dataset oluştur dataset = tf.data.Dataset.from_tensor_slices((features, labels)) # Veri pipeline'ını yapılandır dataset = dataset.shuffle(buffer_size=100) # Veriyi karıştır dataset = dataset.batch(batch_size=32) # Batch'lere ayır dataset = dataset.prefetch(tf.data.AUTOTUNE) # Verileri önceden yükle (performans için) # Bir modeli eğitmek için bu dataset'i kullanabiliriz # Örneğin: # model.fit(dataset, epochs=10) print("\ntf.data.Dataset pipeline'ı oluşturuldu.") print("İlk 2 batch'i göster:") for epoch in range(1): for batch_features, batch_labels in dataset.take(2): print(f" Features shape: {batch_features.shape}, Labels shape: {batch_labels.shape}") ``` ## İleri Seviye Teknikler (DevOps Odaklı) TensorFlow'un temel kullanımlarını anladıktan sonra, özellikle üretim ortamlarında ve büyük ölçekli projelerde performans ve esneklik sağlamak için ileri seviye tekniklere geçebiliriz. Bir DevOps mühendisi olarak, bu teknikler MLOps süreçlerinizi optimize etmenize yardımcı olacaktır. 2026'da modern ML uygulamaları bu yaklaşımları benimsemektedir. ### tf.function ile Performans Optimizasyonu TensorFlow'un `tf.function` dekoratörü, standart Python fonksiyonlarını yüksek performanslı TensorFlow grafikleri olarak derlemenizi sağlar. Bu, özellikle döngüler ve koşullu ifadeler içeren karmaşık hesaplamalarda ciddi hız artışları sağlayabilir. ```python import tensorflow as tf import time # Normal Python fonksiyonu def normal_function(x): for i in tf.range(10000): x = x + tf.constant(1.0) return x # tf.function ile optimize edilmiş fonksiyon @tf.function def tf_function_optimized(x): for i in tf.range(10000): x = x + tf.constant(1.0) return x # Karşılaştırma initial_value = tf.constant(0.0) start_time = time.time() result_normal = normal_function(initial_value) end_time = time.time() print(f"Normal fonksiyon süresi: {end_time - start_time:.4f} saniye") start_time = time.time() result_tf_func = tf_function_optimized(initial_value) end_time = time.time() print(f"tf.function optimize edilmiş süresi: {end_time - start_time:.4f} saniye") ``` ### Custom Layer ve Model Oluşturma TensorFlow'un hazır katmanları yeterli olmadığında veya özel bir mimari tasarlamanız gerektiğinde kendi `tf.keras.layers.Layer` veya `tf.keras.Model` sınıflarınızı oluşturabilirsiniz. Bu, modelinizi daha modüler ve yeniden kullanılabilir hale getirir. ```python import tensorflow as tf # Özel bir aktivasyon katmanı class CustomActivation(tf.keras.layers.Layer): def __init__(self, name=None, **kwargs): super().__init__(name=name, **kwargs) def call(self, inputs): return tf.math.sigmoid(inputs) * inputs # Swish aktivasyonu gibi # Özel bir model oluşturma class CustomModel(tf.keras.Model): def __init__(self, num_classes=10): super().__init__() self.dense1 = tf.keras.layers.Dense(128, activation='relu') self.custom_act = CustomActivation() self.dense2 = tf.keras.layers.Dense(num_classes, activation='softmax') def call(self, inputs): x = self.dense1(inputs) x = self.custom_act(x) return self.dense2(x) # Modeli kullanma model = CustomModel(num_classes=10) model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) # Örnek giriş random_input = tf.random.normal((32, 784)) # Batch size 32, input dim 784 output = model(random_input) print(f"\nCustom Model Çıkış Şekli: {output.shape}") ``` ### Dağıtık Eğitim Stratejileri (tf.distribute.Strategy) Büyük modelleri ve veri setlerini eğitmek için birden fazla GPU veya TPU kullanmak yaygın bir ihtiyaçtır. TensorFlow'un `tf.distribute.Strategy` API'si, kodunuzda minimum değişiklikle dağıtık eğitimi etkinleştirmenizi sağlar. Bu, özellikle 2026'daki gelişmiş donanım altyapılarında kritik öneme sahiptir. ```python import tensorflow as tf # Tek makine, birden fazla GPU için MirroredStrategy strategy = tf.distribute.MirroredStrategy() print(f"Kullanılan dağıtık strateji: {strategy.num_replicas_in_sync} replica ile {strategy.num_replicas_in_sync} cihazda.") with strategy.scope(): # Modelinizi strategy.scope içinde tanımlayın model = tf.keras.Sequential([ tf.keras.layers.Dense(10, activation='relu', input_shape=(10,)), tf.keras.layers.Dense(1, activation='sigmoid') ]) model.compile(optimizer='adam', loss='binary_crossentropy') # Veri seti (örnek) x = tf.random.normal((100, 10)) y = tf.random.uniform((100, 1), maxval=2, dtype=tf.int32) # Modelin dağıtık olarak eğitilmesi print("\nDağıtık model eğitimi başlıyor...") model.fit(x, y, epochs=1, batch_size=32) print("Dağıtık model eğitimi tamamlandı.") ``` > **Uyarı:** `MirroredStrategy` için sisteminizde birden fazla GPU bulunmalıdır. Aksi takdirde varsayılan olarak tek bir cihaz kullanılacaktır. Cloud ortamlarında (GCP TPU'lar gibi) `TPUStrategy` veya `MultiWorkerMirroredStrategy` gibi farklı stratejiler kullanılır. ### TensorFlow Extended (TFX) ve MLOps'a Giriş MLOps (Machine Learning Operations), makine öğrenimi modellerinin geliştirme, dağıtım ve bakım süreçlerini otomatikleştirmeyi ve standartlaştırmayı amaçlayan bir disiplindir. TensorFlow Extended (TFX), Google tarafından geliştirilen, üretim ortamında makine öğrenimi pipeline'ları oluşturmak ve yönetmek için kullanılan bir platformdur. 2026'da MLOps, başarılı yapay zeka projelerinin temelini oluşturmaktadır. TFX, veri doğrulama, özellik mühendisliği, model eğitimi, model analizi ve model sunumu gibi adımları içeren modüller sunar. Bu modüller, TensorFlow Data Validation, TensorFlow Transform, TensorFlow Model Analysis ve TensorFlow Serving gibi bileşenleri kullanır. Bir DevOps mühendisi olarak TFX, model yaşam döngüsünü tutarlı ve ölçeklenebilir bir şekilde yönetmenize olanak tanır. ```python # TFX bileşenlerinin nasıl çalıştığını göstermek için basit bir örnek senaryo: # (Bu kod çalıştırılamaz, sadece konsepti gösterir) # from tfx.orchestration.experimental.interactive.interactive_context import InteractiveContext # from tfx.components import CsvExampleGen, StatisticsGen, SchemaGen, ExampleValidator, Trainer # context = InteractiveContext() # # 1. Veri Alımı (ExampleGen) # example_gen = CsvExampleGen(input_base='/path/to/your/data') # context.run(example_gen) # # 2. Veri İstatistikleri (StatisticsGen) # statistics_gen = StatisticsGen(examples=example_gen.outputs['examples']) # context.run(statistics_gen) # # 3. Şema Çıkarımı (SchemaGen) # schema_gen = SchemaGen(statistics=statistics_gen.outputs['statistics']) # context.run(schema_gen) # # 4. Veri Doğrulama (ExampleValidator) # example_validator = ExampleValidator( # statistics=statistics_gen.outputs['statistics'], # schema=schema_gen.outputs['schema']) # context.run(example_validator) # # 5. Model Eğitimi (Trainer) # trainer = Trainer( # module_file='your_trainer_module.py', # Eğitim kodunuz # examples=example_gen.outputs['examples'], # schema=schema_gen.outputs['schema'], # train_args=tf.estimator.TrainSpec(num_steps=1000), # eval_args=tf.estimator.EvalSpec(num_steps=500)) # context.run(trainer) print("TFX ile MLOps pipeline konsepti. Gerçek kod için TFX dökümantasyonuna bakın.") ``` ## Best Practices & Anti-Patterns (2026) TensorFlow projelerinizi 2026 yılında geliştirirken ve üretim ortamına dağıtırken belirli en iyi uygulamaları takip etmek, hem kod kalitesini artırır hem de MLOps süreçlerinizi optimize eder. İşte deneyimlerimden süzülmüş bazı kritik noktalar: * **✅ Sanal Ortam Kullanımı:** Her proje için ayrı bir Python sanal ortamı (venv veya Conda) kullanın. Bu, bağımlılık çakışmalarını önler ve projenizin taşınabilirliğini artırır. `pip freeze > requirements.txt` ile bağımlılıklarınızı her zaman takip edin. * **❌ Global Değişkenlerden Kaçınma:** Model parametrelerini veya veri yollarını global değişkenler olarak tanımlamaktan kaçının. Bu, kodun test edilmesini ve yeniden kullanılmasını zorlaştırır. Bunun yerine fonksiyon parametreleri veya sınıf üyeleri kullanın. * **✅ tf.function Kullanımı:** Performans kritik kod bloklarınızı `tf.function` ile derleyin. Bu, özellikle döngüler ve karmaşık operasyonlar içeren özel eğitim adımlarında ciddi hız artışları sağlar. * **❌ Veri Ön İşlemeyi Eğitim Koduna Karıştırma:** Veri ön işleme adımlarını model eğitim koduyla karıştırmayın. Bunun yerine `tf.data` API'sini veya TensorFlow Transform gibi araçları kullanarak ayrı, yeniden kullanılabilir veri pipeline'ları oluşturun. * **✅ Model Sürümlendirme:** Eğitilmiş modellerinizi her zaman sürümlendirin ve meta verileriyle birlikte kaydedin (hangi veriyle eğitildiği, hangi parametreler kullanıldığı vb.). TensorFlow SavedModel formatı buna olanak tanır. Bu, üretimde model güncellemelerini ve geri dönüşleri (rollback) kolaylaştırır. * **❌ Hardcoded Yollar ve Ayarlar:** Dosya yollarını, hiperparametreleri veya diğer yapılandırma ayarlarını kod içine gömmeyin. Bunları yapılandırma dosyalarında (YAML, JSON) veya ortam değişkenlerinde tutun, böylece dağıtım ve farklı ortamlar için esneklik sağlarsınız. * **✅ Birim ve Entegrasyon Testleri:** Modellerinizin ve veri pipeline'larınızın doğru çalıştığından emin olmak için kapsamlı testler yazın. TensorFlow'un `tf.test.TestCase` sınıfı, özel katmanları ve modelleri test etmek için kullanışlıdır. * **❌ Güvenlik Açıklarını Göz Ardı Etme:** Modelinizin girişlerini her zaman doğrulayın (input validation). Özellikle kullanıcıdan gelen verilerle beslenen modellerde, adversarial saldırılara karşı dikkatli olun. TensorFlow Privacy gibi kütüphaneleri inceleyin. * **✅ Logging ve İzleme (Monitoring):** Eğitim ve çıkarım süreçlerini detaylı bir şekilde loglayın. TensorFlow'un TensorBoard'u eğitim metriklerini görselleştirmek için harikadır. Üretimdeki model performansını izlemek için Prometheus/Grafana gibi araçlarla entegrasyon kurun. * **❌ Kaynakları Serbest Bırakmayı Unutma:** Özellikle GPU kaynakları kullanırken, işiniz bittiğinde veya bir hata durumunda GPU hafızasını serbest bırakmayı unutmayın. TensorFlow genellikle bunu otomatik yapsa da, uzun süreli veya ardışık işlemler için dikkatli olmak önemlidir. ## Yaygın Hatalar ve Çözümleri (2026) TensorFlow ile çalışırken karşılaşabileceğiniz bazı yaygın hatalar ve bunların 2026 itibarıyla en güncel çözümleri aşağıda listelenmiştir. Bu hatalar, özellikle yeni başlayanlar ve DevOps süreçlerinde ML modellerini yönetenler için sinir bozucu olabilir. ### 1. Problem: GPU Cihazı Bulunamıyor veya Kullanılamıyor * **Sebep:** NVIDIA sürücüleri, CUDA Toolkit veya cuDNN doğru kurulmamış/güncel değil veya TensorFlow sürümü ile uyumsuz. Bazen `tensorflow-gpu` yerine `tensorflow` paketi kurulmuş olabilir. * **Çözüm:** 1. NVIDIA sürücülerinizin 2026 itibarıyla en güncel sürümde olduğundan emin olun. 2. CUDA Toolkit ve cuDNN'in TensorFlow sürümünüzle uyumlu olduğunu kontrol edin (TensorFlow resmi dökümantasyonuna bakın). 3. `pip uninstall tensorflow` ve ardından `pip install tensorflow[and-cuda]` komutuyla GPU destekli TensorFlow'u yeniden kurmayı deneyin. 4. Ortam değişkenlerinin (PATH, LD_LIBRARY_PATH) doğru ayarlandığından emin olun. ### 2. Problem: Shape Mismatch Hatası (Boyut Uyumsuzluğu) * **Sebep:** Sinir ağı katmanlarına verilen giriş tensörlerinin veya etiketlerin beklenen boyutlarıyla uyuşmaması. Örneğin, bir katman 2D giriş beklerken 1D giriş verilmesi. * **Çözüm:** 1. Hata mesajında belirtilen katmanın giriş ve çıkış şekillerini dikkatlice inceleyin. 2. `input_shape` parametresini doğru ayarladığınızdan emin olun. 3. Veri ön işleme adımlarınızda `tf.reshape` veya `tf.expand_dims` gibi fonksiyonlarla tensör boyutlarını kontrol edin. 4. `model.summary()` çıktısına bakarak her katmanın beklediği ve ürettiği şekilleri görselleştirin. ### 3. Problem: Out of Memory (OOM) Hatası * **Sebep:** Özellikle GPU'larda, model veya veri setinin boyutu GPU belleğini aştığında meydana gelir. Büyük batch boyutları veya çok karmaşık modeller bu hataya yol açabilir. * **Çözüm:** 1. **Batch boyutunu küçültün:** Bu genellikle en etkili çözümdür. 2. **Model karmaşıklığını azaltın:** Daha az katman veya daha az nöron kullanmayı düşünün. 3. **Veri tipini optimize edin:** `tf.float32` yerine `tf.float16` (mixed precision training) kullanmayı deneyin (bkz. Performans Optimizasyonu bölümü). 4. **GPU belleği ayarlarını yapın:** `tf.config.experimental.set_memory_growth(gpu, True)` ile TensorFlow'un sadece ihtiyaç duyduğu kadar bellek kullanmasını sağlayın. ### 4. Problem: NaN (Not a Number) Loss Değerleri * **Sebep:** Eğitim sırasında modelin kaybının (loss) `NaN` değerine dönüşmesi. Bu genellikle çok yüksek öğrenme oranları, sayısal kararsızlıklar (örneğin log(0) gibi işlemler) veya hatalı veri ön işleme nedeniyle oluşur. * **Çözüm:** 1. **Öğrenme oranını (learning rate) düşürün:** Genellikle ilk denenecek çözümdür. 2. **Gradient Clipping kullanın:** Gradyanların belirli bir eşiği aşmasını engelleyerek sayısal taşmaları önleyin. 3. **Veri ön işlemeyi kontrol edin:** Giriş verilerinizde `NaN` veya sonsuz değerler olup olmadığını kontrol edin. 4. **Model mimarisini gözden geçirin:** Özellikle özel aktivasyon fonksiyonları veya katmanlar kullanıyorsanız, sayısal kararlılıklarını kontrol edin. 5. **Mixed precision training kullanıyorsanız:** `tf.keras.mixed_precision.set_global_policy('mixed_float16')` uyguladıktan sonra `loss_scale` stratejisi kullandığınızdan emin olun. ## Performans Optimizasyonu (2026) TensorFlow modellerinin performansını optimize etmek, özellikle büyük veri setleri ve karmaşık derin öğrenme mimarileriyle çalışırken kritik öneme sahiptir. 2026 yılında, donanım kaynaklarını en verimli şekilde kullanmak ve eğitim/çıkarım sürelerini kısaltmak için aşağıdaki teknikleri uygulayabilirsiniz. ### 1. Veri Pipeline Optimizasyonu (tf.data) Veri okuma ve ön işleme, genellikle model eğitiminin darboğazıdır. `tf.data` API'si, verimli veri pipeline'ları oluşturmak için tasarlanmıştır. `map`, `batch`, `shuffle`, `prefetch` ve `cache` gibi yöntemleri kullanarak performansı artırabilirsiniz. ```python import tensorflow as tf import numpy as np import time # Büyük bir yapay veri seti oluşturalım num_samples = 100000 features = np.random.rand(num_samples, 100).astype(np.float32) labels = np.random.randint(0, 2, size=num_samples).astype(np.int32) def parse_function(feature, label): # Basit bir ön işleme adımı (örneğin ölçekleme) feature = feature / 255.0 return feature, label # Optimize edilmemiş pipeline def create_unoptimized_dataset(): dataset = tf.data.Dataset.from_tensor_slices((features, labels)) dataset = dataset.map(parse_function) dataset = dataset.batch(32) return dataset # Optimize edilmiş pipeline def create_optimized_dataset(): dataset = tf.data.Dataset.from_tensor_slices((features, labels)) dataset = dataset.shuffle(buffer_size=10000) dataset = dataset.map(parse_function, num_parallel_calls=tf.data.AUTOTUNE) dataset = dataset.batch(32) dataset = dataset.prefetch(tf.data.AUTOTUNE) return dataset # Performans karşılaştırması print("\nVeri Pipeline Optimizasyonu Karşılaştırması:") start_time = time.time() for _ in create_unoptimized_dataset(): pass end_time = time.time() print(f"Optimize edilmemiş pipeline süresi: {end_time - start_time:.4f} saniye") start_time = time.time() for _ in create_optimized_dataset(): pass end_time = time.time() print(f"Optimize edilmiş pipeline süresi: {end_time - start_time:.4f} saniye") ``` ### 2. Mixed Precision Training (Karışık Hassasiyet Eğitimi) `tf.float16` (yarım hassasiyetli kayan nokta) ve `tf.float32` (tek hassasiyetli) veri tiplerini birlikte kullanarak G