TensorFlow完全ガイド：機械学習の革新的フレームワーク

# CPU版のインストール
pip install tensorflow

# GPU版（CUDA対応）のインストール
pip install tensorflow[and-cuda]

# 特定バージョンのインストール
pip install tensorflow==2.15.0

import tensorflow as tf
import numpy as np

# 基本的なテンソル操作
a = tf.constant([1, 2, 3, 4])
b = tf.constant([5, 6, 7, 8])

# 基本演算
print("加算:", tf.add(a, b))
print("乗算:", tf.multiply(a, b))
print("行列の積:", tf.matmul(tf.reshape(a, [2, 2]), tf.reshape(b, [2, 2])))

# テンソルの形状操作
x = tf.constant([[1, 2], [3, 4], [5, 6]])
print("元の形状:", x.shape)
print("転置:", tf.transpose(x))
print("平坦化:", tf.reshape(x, [-1]))

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

# サンプルデータの生成
np.random.seed(42)
X = np.random.randn(100, 1)
y = 3 * X + 2 + np.random.randn(100, 1) * 0.1

# データの正規化
X = tf.constant(X, dtype=tf.float32)
y = tf.constant(y, dtype=tf.float32)

# モデルのパラメータ
W = tf.Variable(tf.random.normal([1, 1]), name='weight')
b = tf.Variable(tf.random.normal([1]), name='bias')

# 線形モデルの定義
def linear_model(x):
    return tf.matmul(x, W) + b

# 損失関数（平均二乗誤差）
def loss_fn(y_true, y_pred):
    return tf.reduce_mean(tf.square(y_true - y_pred))

# 最適化アルゴリズム
optimizer = tf.optimizers.SGD(learning_rate=0.01)

# 訓練ループ
for epoch in range(1000):
    with tf.GradientTape() as tape:
        y_pred = linear_model(X)
        loss = loss_fn(y, y_pred)
    
    # 勾配の計算と更新
    gradients = tape.gradient(loss, [W, b])
    optimizer.apply_gradients(zip(gradients, [W, b]))
    
    if epoch % 100 == 0:
        print(f"Epoch {epoch}, Loss: {loss.numpy():.4f}")

print(f"学習後のパラメータ: W={W.numpy()}, b={b.numpy()}")

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

# CIFAR-10データセットの読み込み
(x_train, y_train), (x_test, y_test) = keras.datasets.cifar10.load_data()

# データの前処理
x_train = x_train.astype("float32") / 255.0
x_test = x_test.astype("float32") / 255.0
y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)

# CNNモデルの構築
model = keras.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.Flatten(),
    layers.Dense(64, activation='relu'),
    layers.Dropout(0.5),
    layers.Dense(10, activation='softmax')
])

# モデルのコンパイル
model.compile(
    optimizer='adam',
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

# モデルの概要表示
model.summary()

# モデルの訓練
history = model.fit(
    x_train, y_train,
    batch_size=32,
    epochs=10,
    validation_data=(x_test, y_test),
    verbose=1
)

# モデルの評価
test_loss, test_accuracy = model.evaluate(x_test, y_test, verbose=0)
print(f"テスト精度: {test_accuracy:.4f}")

import tensorflow as tf
from tensorflow import keras
import numpy as np

# データセットの準備
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
x_train = x_train.reshape(-1, 784).astype("float32") / 255.0
x_test = x_test.reshape(-1, 784).astype("float32") / 255.0
y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)

# データセットの作成
batch_size = 32
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_dataset = train_dataset.shuffle(1000).batch(batch_size)

# モデルの定義
model = keras.Sequential([
    layers.Dense(128, activation='relu', input_shape=(784,)),
    layers.Dropout(0.2),
    layers.Dense(10, activation='softmax')
])

# 損失関数と最適化アルゴリズム
loss_fn = keras.losses.CategoricalCrossentropy()
optimizer = keras.optimizers.Adam()

# 評価指標
train_loss = keras.metrics.Mean(name='train_loss')
train_accuracy = keras.metrics.CategoricalAccuracy(name='train_accuracy')

# 訓練ステップの定義
@tf.function
def train_step(x, y):
    with tf.GradientTape() as tape:
        predictions = model(x, training=True)
        loss = loss_fn(y, predictions)
    
    gradients = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(gradients, model.trainable_variables))
    
    train_loss(loss)
    train_accuracy(y, predictions)

# カスタム訓練ループ
epochs = 5
for epoch in range(epochs):
    # メトリクスのリセット
    train_loss.reset_states()
    train_accuracy.reset_states()
    
    # バッチごとの訓練
    for x_batch, y_batch in train_dataset:
        train_step(x_batch, y_batch)
    
    print(f"Epoch {epoch + 1}/{epochs}, "
          f"Loss: {train_loss.result():.4f}, "
          f"Accuracy: {train_accuracy.result():.4f}")

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import numpy as np

# 事前訓練済みモデルの読み込み（ImageNet重み）
base_model = keras.applications.VGG16(
    weights='imagenet',
    include_top=False,
    input_shape=(224, 224, 3)
)

# ベースモデルの重みを固定
base_model.trainable = False

# 新しいモデルの構築
model = keras.Sequential([
    base_model,
    layers.GlobalAveragePooling2D(),
    layers.Dense(128, activation='relu'),
    layers.Dropout(0.5),
    layers.Dense(1, activation='sigmoid')  # 二値分類の例
])

# モデルのコンパイル
model.compile(
    optimizer='adam',
    loss='binary_crossentropy',
    metrics=['accuracy']
)

# モデル構造の確認
model.summary()

# ファインチューニングの例
def fine_tune_model(model, base_model):
    # ベースモデルの一部レイヤーを訓練可能にする
    base_model.trainable = True
    
    # 最後の数層のみ訓練可能にする
    fine_tune_at = len(base_model.layers) - 10
    for layer in base_model.layers[:fine_tune_at]:
        layer.trainable = False
    
    # より小さな学習率で再コンパイル
    model.compile(
        optimizer=keras.optimizers.Adam(learning_rate=0.0001/10),
        loss='binary_crossentropy',
        metrics=['accuracy']
    )
    
    return model

import tensorflow as tf
from tensorflow.keras import layers, models

# データの読み込み
(train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.mnist.load_data()

# データの前処理
train_images = train_images.reshape((60000, 28, 28, 1)).astype('float32') / 255
test_images = test_images.reshape((10000, 28, 28, 1)).astype('float32') / 255

train_labels = tf.keras.utils.to_categorical(train_labels)
test_labels = tf.keras.utils.to_categorical(test_labels)

# CNNモデルの構築
model = models.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.Flatten(),
    layers.Dense(64, activation='relu'),
    layers.Dense(10, activation='softmax')
])

# コンパイル
model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

# モデルの概要表示
model.summary()

# 訓練
history = model.fit(train_images, train_labels,
                    epochs=5,
                    batch_size=64,
                    validation_data=(test_images, test_labels))

# 評価
test_loss, test_accuracy = model.evaluate(test_images, test_labels, verbose=0)
print(f'テスト精度: {test_accuracy:.4f}')

import tensorflow as tf
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences

# サンプルデータ
texts = [
    "この映画は本当に素晴らしかった",
    "つまらない映画だった",
    "感動的なストーリーでした",
    "時間の無駄だった",
    "最高の体験でした"
]
labels = [1, 0, 1, 0, 1]  # 1: ポジティブ, 0: ネガティブ

# テキストの前処理
tokenizer = Tokenizer(num_words=1000)
tokenizer.fit_on_texts(texts)
sequences = tokenizer.texts_to_sequences(texts)
data = pad_sequences(sequences, maxlen=10)

# モデルの構築
model = tf.keras.Sequential([
    tf.keras.layers.Embedding(1000, 16, input_length=10),
    tf.keras.layers.GlobalAveragePooling1D(),
    tf.keras.layers.Dense(16, activation='relu'),
    tf.keras.layers.Dense(1, activation='sigmoid')
])

# コンパイル
model.compile(optimizer='adam',
              loss='binary_crossentropy',
              metrics=['accuracy'])

# 訓練
model.fit(data, labels, epochs=10, verbose=1)

# 新しいテキストの感情予測
new_text = ["この商品は期待以上でした"]
new_sequence = tokenizer.texts_to_sequences(new_text)
new_data = pad_sequences(new_sequence, maxlen=10)
prediction = model.predict(new_data)
print(f"感情スコア: {prediction[0][0]:.4f}")