Rename pages/15_Graphs.py to pages/15_TransferLearning_HF.py

pages/15_Graphs.py

@@ -1,97 +0,0 @@
-import streamlit as st
-import tensorflow as tf
-import tensorflow_gnn as tfgnn
-from tensorflow_gnn.models import mt_albis
-import networkx as nx
-import matplotlib.pyplot as plt
-
-# Set environment variable for legacy Keras
-import os
-os.environ['TF_USE_LEGACY_KERAS'] = '1'
-
-# Define the model function
-def model_fn(graph_tensor_spec: tfgnn.GraphTensorSpec):
-    graph = inputs = tf.keras.Input(type_spec=graph_tensor_spec)
-
-    # Encode input features to match the required output shape of 128
-    graph = tfgnn.keras.layers.MapFeatures(
-        node_sets_fn=lambda node_set, node_set_name: tf.keras.layers.Dense(128)(node_set['features'])
-    )(graph)
-
-    # For each round of message passing...
-    for _ in range(2):
-        # ... create and apply a Keras layer.
-        graph = mt_albis.MtAlbisGraphUpdate(
-            units=128, message_dim=64,
-            attention_type="none", simple_conv_reduce_type="mean",
-            normalization_type="layer", next_state_type="residual",
-            state_dropout_rate=0.2, l2_regularization=1e-5,
-            receiver_tag=tfgnn.TARGET  # Use TARGET instead of NODES
-        )(graph)
-
-    return tf.keras.Model(inputs, graph)
-
-# Function to create a sample graph
-def create_sample_graph():
-    num_nodes = 10
-    num_edges = 15
-
-    graph = nx.gnm_random_graph(num_nodes, num_edges, directed=True)
-
-    # Create a GraphTensor
-    node_features = tf.random.normal((num_nodes, 128))  # Match the dense layer output
-    edge_features = tf.random.normal((num_edges, 32))
-
-    graph_tensor = tfgnn.GraphTensor.from_pieces(
-        node_sets={
-            "papers": tfgnn.NodeSet.from_fields(
-                sizes=[num_nodes],
-                features={"features": node_features}
-            )
-        },
-        edge_sets={
-            "cites": tfgnn.EdgeSet.from_fields(
-                sizes=[num_edges],
-                adjacency=tfgnn.Adjacency.from_indices(
-                    source=("papers", tf.constant([e[0] for e in graph.edges()], dtype=tf.int32)),
-                    target=("papers", tf.constant([e[1] for e in graph.edges()], dtype=tf.int32))
-                ),
-                features={"features": edge_features}
-            )
-        }
-    )
-
-    return graph, graph_tensor
-
-# Streamlit app
-def main():
-    st.title("Graph Neural Network Architecture Visualization")
-
-    # Create sample graph
-    nx_graph, graph_tensor = create_sample_graph()
-
-    # Create and compile the model
-    model = model_fn(graph_tensor.spec)
-    model.compile(optimizer='adam', loss='binary_crossentropy')
-
-    # Display model summary
-    st.subheader("Model Summary")
-    model.summary(print_fn=lambda x: st.text(x))
-
-    # Visualize the graph
-    st.subheader("Sample Graph Visualization")
-    fig, ax = plt.subplots(figsize=(10, 8))
-    pos = nx.spring_layout(nx_graph)
-    nx.draw(nx_graph, pos, with_labels=True, node_color='lightblue',
-            node_size=500, arrowsize=20, ax=ax)
-    st.pyplot(fig)
-
-    # Display graph tensor info
-    st.subheader("Graph Tensor Information")
-    st.text(f"Number of nodes: {graph_tensor.node_sets['papers'].total_size}")
-    st.text(f"Number of edges: {graph_tensor.edge_sets['cites'].total_size}")
-    st.text(f"Node feature shape: {graph_tensor.node_sets['papers']['features'].shape}")
-    st.text(f"Edge feature shape: {graph_tensor.edge_sets['cites']['features'].shape}")
-
-if __name__ == "__main__":
-    main()

pages/15_TransferLearning_HF.py

@@ -0,0 +1,85 @@
+import streamlit as st
+import tensorflow as tf
+from transformers import ViTFeatureExtractor, TFAutoModelForImageClassification
+import tensorflow_datasets as tfds
+import matplotlib.pyplot as plt
+import numpy as np
+
+# Load the dataset
+dataset_name = "cats_vs_dogs"
+(ds_train, ds_val), ds_info = tfds.load(dataset_name, split=['train[:80%]', 'train[80%:]'], with_info=True, as_supervised=True)
+
+# Preprocess the dataset
+def preprocess_image(image, label):
+    image = tf.image.resize(image, (224, 224))  # ViT requires 224x224 images
+    image = image / 255.0
+    return image, label
+
+ds_train = ds_train.map(preprocess_image).batch(32).prefetch(tf.data.AUTOTUNE)
+ds_val = ds_val.map(preprocess_image).batch(32).prefetch(tf.data.AUTOTUNE)
+
+# Streamlit app
+st.title("Transfer Learning with Vision Transformer for Image Classification")
+
+# Input parameters
+batch_size = st.slider("Batch Size", 16, 128, 32, 16)
+epochs = st.slider("Epochs", 5, 50, 10, 5)
+
+# Load the pre-trained Vision Transformer model
+model_name = "google/vit-base-patch16-224-in21k"
+feature_extractor = ViTFeatureExtractor.from_pretrained(model_name)
+base_model = TFAutoModelForImageClassification.from_pretrained(model_name, num_labels=2)  # Cats vs Dogs has 2 classes
+
+# Freeze the convolutional base
+base_model.trainable = False
+
+# Add custom layers on top
+inputs = tf.keras.Input(shape=(224, 224, 3))
+x = feature_extractor(inputs)
+x = tf.keras.layers.Flatten()(base_model(x)[0])
+x = tf.keras.layers.Dense(256, activation='relu')(x)
+x = tf.keras.layers.Dropout(0.5)(x)
+outputs = tf.keras.layers.Dense(1, activation='sigmoid')(x)
+model = tf.keras.Model(inputs, outputs)
+
+model.summary()
+
+# Compile the model
+model.compile(optimizer='adam',
+              loss='binary_crossentropy',  # Change loss function based on the number of classes
+              metrics=['accuracy'])
+
+# Train the model
+if st.button("Train Model"):
+    with st.spinner("Training the model..."):
+        history = model.fit(
+            ds_train,
+            epochs=epochs,
+            validation_data=ds_val
+        )
+        
+        st.success("Model training completed!")
+
+    # Display training curves
+    st.subheader("Training and Validation Accuracy")
+    fig, ax = plt.subplots()
+    ax.plot(history.history['accuracy'], label='Training Accuracy')
+    ax.plot(history.history['val_accuracy'], label='Validation Accuracy')
+    ax.set_xlabel('Epoch')
+    ax.set_ylabel('Accuracy')
+    ax.legend()
+    st.pyplot(fig)
+
+    st.subheader("Training and Validation Loss")
+    fig, ax = plt.subplots()
+    ax.plot(history.history['loss'], label='Training Loss')
+    ax.plot(history.history['val_loss'], label='Validation Loss')
+    ax.set_xlabel('Epoch')
+    ax.set_ylabel('Loss')
+    ax.legend()
+    st.pyplot(fig)
+
+# Evaluate the model
+if st.button("Evaluate Model"):
+    test_loss, test_acc = model.evaluate(ds_val, verbose=2)
+    st.write(f"Validation accuracy: {test_acc}")