AI ML Tools

1
2
3
4
5
6
7
8
9
10
11
12
13
import pandas as pd
import numpy as np

# Veri okuma
df = pd.read_csv('data.csv')

# Veri analizi
summary = df.describe()
missing_values = df.isnull().sum()

# Veri manipülasyonu
df['new_column'] = df['old_column'].apply(lambda x: x * 2)
df = df.groupby('category').agg({'value': 'mean'})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import seaborn as sns
import matplotlib.pyplot as plt

# Dağılım grafiği
plt.figure(figsize=(10, 6))
sns.histplot(data=df, x='value', hue='category')
plt.title('Değer Dağılımı')
plt.show()

# Korelasyon matrisi
plt.figure(figsize=(12, 8))
sns.heatmap(df.corr(), annot=True, cmap='coolwarm')
plt.title('Korelasyon Matrisi')
plt.show()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import torch
import torch.nn as nn

class NeuralNetwork(nn.Module):
    def __init__(self):
        super().__init__()
        self.layers = nn.Sequential(
            nn.Linear(784, 128),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(128, 10)
        )
    
    def forward(self, x):
        return self.layers(x)

# Model eğitimi
model = NeuralNetwork()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters())

for epoch in range(num_epochs):
    for batch in dataloader:
        optimizer.zero_grad()
        outputs = model(batch.x)
        loss = criterion(outputs, batch.y)
        loss.backward()
        optimizer.step()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import tensorflow as tf

# Model oluşturma
model = tf.keras.Sequential([
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(10, activation='softmax')
])

# Model derleme
model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# Model eğitimi
history = model.fit(
    x_train, y_train,
    epochs=10,
    validation_data=(x_val, y_val)
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import mlflow

# Deney takibi
mlflow.start_run()

# Parametreleri kaydet
mlflow.log_param("learning_rate", 0.01)
mlflow.log_param("num_epochs", 10)

# Metrikleri kaydet
mlflow.log_metric("accuracy", 0.95)
mlflow.log_metric("loss", 0.05)

# Modeli kaydet
mlflow.pytorch.log_model(model, "model")

mlflow.end_run()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
from transformers import pipeline

# Metin sınıflandırma
classifier = pipeline("sentiment-analysis")
result = classifier("Bu ürün gerçekten harika!")

# Metin üretme
generator = pipeline("text-generation")
text = generator(
    "Yapay zeka teknolojileri",
    max_length=50,
    num_return_sequences=1
)[0]['generated_text']

# Soru cevaplama
qa = pipeline("question-answering")
context = "Yapay zeka, insan zekasını taklit eden sistemlerdir."
question = "Yapay zeka nedir?"
answer = qa(question=question, context=context)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import spacy

# Türkçe model yükleme
nlp = spacy.load("tr_core_news_lg")

# Metin işleme
doc = nlp("Yapay zeka ve makine öğrenmesi çok önemli teknolojilerdir.")

# Named Entity Recognition
for ent in doc.ents:
    print(f"Entity: {ent.text}, Label: {ent.label_}")

# Dependency Parsing
for token in doc:
    print(f"{token.text} -> {token.dep_}")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import cv2
import numpy as np

# Görüntü okuma ve işleme
img = cv2.imread('image.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Kenar tespiti
edges = cv2.Canny(gray, 100, 200)

# Yüz tespiti
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
faces = face_cascade.detectMultiScale(gray, 1.3, 5)

for (x, y, w, h) in faces:
    cv2.rectangle(img, (x, y), (x+w, y+h), (255, 0, 0), 2)

1
2
3
4
5
6
7
8
9
10
11
12
from PIL import Image, ImageEnhance

# Görüntü işleme
image = Image.open('image.jpg')
enhancer = ImageEnhance.Brightness(image)
brightened = enhancer.enhance(1.5)

# Görüntü boyutlandırma
resized = image.resize((800, 600))

# Görüntü döndürme
rotated = image.rotate(45)

1
2
3
4
5
6
7
8
9
10
11
12
13
import autokeras as ak

# Image classification
clf = ak.ImageClassifier(
    max_trials=10,
    overwrite=True
)

# Model arama ve eğitim
clf.fit(x_train, y_train, epochs=10)

# En iyi modeli al
model = clf.export_model()

1
2
3
4
5
6
7
8
9
10
from pycaret.classification import *

# Deney ortamı kurulumu
exp = setup(data, target='target')

# En iyi modeli bul
best_model = compare_models()

# Model tahminleri
predictions = predict_model(best_model, data=test_data)

1
2
3
4
5
6
7
8
9
10
11
12
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class PredictionInput(BaseModel):
    features: List[float]

@app.post("/predict")
async def predict(input_data: PredictionInput):
    prediction = model.predict([input_data.features])
    return {"prediction": prediction.tolist()}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import wandb

# Deney başlatma
wandb.init(project="my-project")

# Konfigürasyon
config = wandb.config
config.learning_rate = 0.01
config.batch_size = 32

# Metrik loglama
wandb.log({
    "accuracy": 0.95,
    "loss": 0.05
})

# Görsel loglama
wandb.log({
    "confusion_matrix": wandb.plot.confusion_matrix(
        y_true=y_true,
        preds=y_pred,
        class_names=classes
    )
})

1
2
3
4
5
6
7
8
9
10
11
12
from torch.utils.tensorboard import SummaryWriter

writer = SummaryWriter('runs/experiment_1')

# Metrik loglama
writer.add_scalar('Loss/train', loss, epoch)
writer.add_scalar('Accuracy/train', acc, epoch)

# Model grafiği
writer.add_graph(model, input_to_model)

writer.close()