Create Deeplearning for NLP.py

pages/Deeplearning for NLP.py

@@ -0,0 +1,111 @@
+import streamlit as st
+import numpy as np
+import torch
+from torch import nn
+import tensorflow as tf
+from tensorflow import keras
+from tensorflow.keras import layers
+
+# Set page config
+st.set_page_config(page_title='Advanced NLP with Deep Learning', layout='wide')
+
+# Title with styled emoji
+st.markdown('<h1 style="color:#4CAF50; text-align:center;">🤖 Advanced NLP with Deep Learning 🚀</h1>', unsafe_allow_html=True)
+
+# Section 1: Word Embeddings
+st.markdown('<h2 style="color:#FF5733">📌 1. Word Embeddings</h2>', unsafe_allow_html=True)
+
+st.subheader('🔎 Definition:')
+st.write("""
+Word embeddings are dense vector representations of words where similar words have similar representations. They are essential for text-based deep learning models.
+
+- **🔹 Word2Vec (Skip-gram & CBOW)**: Learns word representations based on context.
+- **🔹 GloVe (Global Vectors)**: Uses word co-occurrence statistics to learn embeddings.
+- **🔹 FastText**: Handles subword information, helping with out-of-vocabulary words.
+""")
+
+# Word2Vec Example
+st.subheader('🧩 Word2Vec Example:')
+sentence = st.text_area("Enter a sentence to visualize Word2Vec embeddings", "NLP is amazing and very useful.")
+
+if st.button('🎨 Visualize Word2Vec'):
+    words = sentence.split()
+    embeddings = {word: np.random.rand(1, 50) for word in words}
+    st.write("**Word2Vec Embeddings (Random Example):**")
+    for word, emb in embeddings.items():
+        st.write(f"{word}: {emb.flatten()[:5]}...")
+
+# Section 2: Sequence Models
+st.markdown('<h2 style="color:#3E7FCB">📌 2. Sequence Models</h2>', unsafe_allow_html=True)
+
+st.subheader('🔎 Definition:')
+st.write("""
+Sequence models process sequential data like sentences and play a key role in NLP tasks like translation, summarization, and sentiment analysis.
+
+- **🔹 RNN (Recurrent Neural Networks)**: Maintains memory of previous words.
+- **🔹 LSTM (Long Short-Term Memory)**: Handles long-range dependencies.
+- **🔹 GRU (Gated Recurrent Units)**: A simplified LSTM version.
+""")
+
+# RNN Example
+st.subheader('🛠️ RNN Example (PyTorch):')
+if st.button('🖥️ Show RNN Model Architecture'):
+    class SimpleRNN(nn.Module):
+        def __init__(self, input_size, hidden_size, output_size):
+            super(SimpleRNN, self).__init__()
+            self.rnn = nn.RNN(input_size, hidden_size, batch_first=True)
+            self.fc = nn.Linear(hidden_size, output_size)
+        
+        def forward(self, x):
+            out, _ = self.rnn(x)
+            out = self.fc(out[:, -1, :])
+            return out
+    
+    rnn_model = SimpleRNN(input_size=10, hidden_size=20, output_size=1)
+    st.write("**RNN Architecture:**")
+    st.write(rnn_model)
+
+# Section 3: Attention Mechanisms
+st.markdown('<h2 style="color:#E67E22">📌 3. Attention Mechanisms</h2>', unsafe_allow_html=True)
+
+st.subheader('🔎 Definition:')
+st.write("""
+Attention mechanisms allow models to focus on key parts of an input sequence, improving performance on tasks that require long-range dependencies.
+
+- **🔹 Self-attention**: Assigns importance to different words.
+- **🔹 Seq2Seq Models**: Encoder-decoder models used for translation.
+- **🔹 Transformer**: Parallel processing for high efficiency.
+""")
+
+# Transformer Example
+st.subheader('🛠️ Transformer Example (Simplified):')
+if st.button('🖥️ Show Transformer Architecture'):
+    transformer_model = keras.Sequential([
+        layers.InputLayer(input_shape=(None, 512)),
+        layers.MultiHeadAttention(num_heads=8, key_dim=512),
+        layers.GlobalAveragePooling1D(),
+        layers.Dense(256, activation="relu"),
+        layers.Dense(1)
+    ])
+    st.write("**Transformer Architecture (Simplified):**")
+    st.write(transformer_model)
+
+# Section 4: Key Attention Components
+st.markdown('<h2 style="color:#9C27B0">📌 4. Attention Components</h2>', unsafe_allow_html=True)
+
+st.subheader('🔍 Self-attention:')
+st.write("""
+Each word in a sequence attends to all other words and assigns an importance weight, capturing long-range dependencies.
+""")
+
+st.subheader('🔄 Seq2Seq:')
+st.write("""
+Used for translation, where an encoder processes input and a decoder generates output.
+""")
+
+st.subheader('⚡ Transformer:')
+st.write("""
+Revolutionized NLP by using self-attention in both encoder and decoder while processing all tokens in parallel.
+""")
+
+st.markdown('<h3 style="color:#4CAF50; text-align:center;">✨ Thanks for Exploring NLP! ✨</h3>', unsafe_allow_html=True)