tensarflows 0.1.0__tar.gz

tensarflows-0.1.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.5
+Name: tensarflows
+Version: 0.1.0
+Summary: A Python package containing GAN and RNN-LSTM source code
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# Tensarflows
+
+## Installation
+
+```bash
+pip install tensarflows

tensarflows-0.1.0/README.md

@@ -0,0 +1,6 @@
+# Tensarflows
+
+## Installation
+
+```bash
+pip install tensarflows

tensarflows-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "tensarflows"
+version = "0.1.0"
+description = "A Python package containing GAN and RNN-LSTM source code"
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = []
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/tensarflows"]
+
+[tool.hatch.build.targets.sdist]
+only-include = [
+    "src/tensarflows",
+    "README.md",
+    "pyproject.toml"
+]

tensarflows-0.1.0/src/tensarflows/GAN.py

@@ -0,0 +1,107 @@
+import tensorflow as tf
+from tensorflow.keras import layers
+import matplotlib.pyplot as plt
+
+# 1. Load MNIST dataset
+(x_train, _), _ = tf.keras.datasets.mnist.load_data()
+
+# folder = input("Enter image folder path: ")
+# images = []
+
+# for file in os.listdir(folder):
+#     path = os.path.join(folder, file)
+#     img = cv2.imread(path, cv2.IMREAD_GRAYSCALE)
+
+#     if img is not None:
+#         img = cv2.resize(img, (28, 28))
+#         images.append(img)
+
+# x_train = np.array(images)
+# Normalize pixel values from 0-255 to -1 to 1
+x_train = (x_train - 127.5) / 127.5
+
+# Convert each 28x28 image into 784 values
+x_train = x_train.reshape(-1, 784)
+
+# 2. Create Generator
+G = tf.keras.Sequential([
+    layers.Dense(256, activation='relu', input_shape=(100,)),
+    layers.Dense(784, activation='tanh')
+])
+
+# 3. Create Discriminator
+D = tf.keras.Sequential([
+    layers.Dense(256, activation='relu', input_shape=(784,)),
+    layers.Dense(1, activation='sigmoid')
+])
+
+# 4. Loss function and optimizers
+loss = tf.keras.losses.BinaryCrossentropy()
+
+G_optimizer = tf.keras.optimizers.Adam(0.0002)
+D_optimizer = tf.keras.optimizers.Adam(0.0002)
+
+# 5. Train the GAN
+for epoch in range(10):
+
+    for i in range(0, len(x_train), 128):
+
+        # Get a batch of real images
+        real = x_train[i:i+128]
+        n = len(real)
+
+        # Generate random noise
+        noise = tf.random.normal((n, 100))
+
+        # Generate fake images
+        fake = G(noise)
+
+        # Train Discriminator
+        with tf.GradientTape() as tape:
+            real_output = D(real)
+            fake_output = D(tf.stop_gradient(fake))
+
+            real_loss = loss(tf.ones_like(real_output), real_output)
+            fake_loss = loss(tf.zeros_like(fake_output), fake_output)
+
+            D_loss = real_loss + fake_loss
+
+        gradients = tape.gradient(D_loss, D.trainable_variables)
+        D_optimizer.apply_gradients(
+            zip(gradients, D.trainable_variables)
+        )
+
+        # Train Generator
+        noise = tf.random.normal((n, 100))
+
+        with tf.GradientTape() as tape:
+            fake = G(noise)
+            output = D(fake)
+
+            G_loss = loss(tf.ones_like(output), output)
+
+        gradients = tape.gradient(G_loss, G.trainable_variables)
+        G_optimizer.apply_gradients(
+            zip(gradients, G.trainable_variables)
+        )
+
+    print("Epoch:", epoch + 1,
+          "D Loss:", float(D_loss),
+          "G Loss:", float(G_loss))
+
+# 6. Generate new images
+noise = tf.random.normal((16, 100))
+images = G(noise, training=False).numpy()
+
+# Convert images into 28x28 format
+images = images.reshape(16, 28, 28)
+
+# Display generated images
+plt.figure(figsize=(6, 6))
+
+for i in range(16):
+    plt.subplot(4, 4, i + 1)
+    plt.imshow(images[i], cmap='gray')
+    plt.axis('off')
+
+plt.show()

tensarflows-0.1.0/src/tensarflows/__init__.py

@@ -0,0 +1,17 @@
+from pathlib import Path
+
+__version__ = "0.1.0"
+
+PACKAGE_DIR = Path(__file__).parent
+
+def print_source(filename):
+    """Print the complete source code of a package module."""
+    allowed_files = {"GAN.py", "rnn_lstm.py"}
+
+    if filename not in allowed_files:
+        raise ValueError(f"Unsupported file: {filename}")
+
+    file_path = PACKAGE_DIR / filename
+
+    print(f"\n{'=' * 20} {filename} {'=' * 20}\n")
+    print(file_path.read_text(encoding="utf-8"))

tensarflows-0.1.0/src/tensarflows/rnn_lstm.py

@@ -0,0 +1,366 @@
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras import layers, models
+# ---------------------------------------------------------------
+# 1. Load the dataset
+# ---------------------------------------------------------------
+path = tf.keras.utils.get_file(
+    "shakespeare.txt",
+    "https://storage.googleapis.com/download.tensorflow.org/data/shakespeare.txt",
+)
+text = open(path, "rb").read().decode("utf-8")
+
+MAX_CHARS = None            # e.g. 300_000 for a faster, lower-quality run on CPU
+if MAX_CHARS:
+    text = text[:MAX_CHARS]
+
+print("Total characters:", len(text))
+print(text[:200])
+# ---------------------------------------------------------------
+# 2. Vocabulary: character <-> integer
+# ---------------------------------------------------------------
+vocab = sorted(set(text))
+char2idx = {c: i for i, c in enumerate(vocab)}
+idx2char = np.array(vocab)
+vocab_size = len(vocab)
+print("Unique characters:", vocab_size)
+
+data = np.array([char2idx[c] for c in text], dtype="int32")
+
+# ---------------------------------------------------------------
+# 3. Build training data: input = 100 chars, target = same 100 chars
+#    shifted by one (the model predicts the next char at EVERY step)
+# ---------------------------------------------------------------
+SEQ_LEN = 100
+BATCH_SIZE = 64
+
+ds = tf.data.Dataset.from_tensor_slices(data)
+sequences = ds.batch(SEQ_LEN + 1, drop_remainder=True)
+dataset = (
+    sequences.map(lambda s: (s[:-1], s[1:]))
+    .shuffle(10_000)
+    .batch(BATCH_SIZE, drop_remainder=True)
+    .prefetch(tf.data.AUTOTUNE)
+)
+# # ---------------------------------------------------------------
+# 4. Model: Embedding -> RNN (return_sequences) -> Dense
+# ---------------------------------------------------------------
+model = models.Sequential([
+    layers.Input(shape=(None,)),
+    layers.Embedding(vocab_size, 128),
+    layers.SimpleRNN(256, return_sequences=True),
+    layers.Dense(vocab_size),            # raw logits (no softmax)
+])
+
+model.compile(
+    optimizer="adam",
+    loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
+)
+model.summary()
+
+# ---------------------------------------------------------------
+# 5. Train (aim for loss around 1.4 - 1.6)
+# ---------------------------------------------------------------
+EPOCHS = 15
+model.fit(dataset, epochs=EPOCHS)
+# ---------------------------------------------------------------
+# 6. Generate text, one character at a time
+# ---------------------------------------------------------------
+def generate(seed, num_chars=500, temperature=0.8):
+    """
+    temperature < 1.0 : safer, more predictable text
+    temperature > 1.0 : more random / creative, more mistakes
+    """
+    ids = [char2idx.get(c, 0) for c in seed]
+    for _ in range(num_chars):
+        x = np.array([ids[-SEQ_LEN:]])
+        logits = model(x, training=False)[0, -1] / temperature
+        next_id = tf.random.categorical(logits[None, :], 1)[0, 0].numpy()
+        ids.append(int(next_id))
+    return "".join(idx2char[i] for i in ids)
+
+1
+print("\n=== Text generation ===")
+print(generate("ROMEO: ", num_chars=500, temperature=0.8))
+# Machine translation 
+"""
+RNN applications in TensorFlow / Keras
+1. Text generation      (many-to-one, character-level LSTM)
+2. Machine translation  (many-to-many, encoder-decoder seq2seq LSTM)
+3. POS tagging          (many-to-many, Bidirectional LSTM)
+
+Toy datasets are used so every part runs quickly. Replace them with real data.
+Requires: pip install tensorflow numpy
+"""
+
+# =====================================================================
+# 2. MACHINE TRANSLATION (encoder-decoder seq2seq, English -> French)
+# =====================================================================
+def machine_translation_demo():
+    pairs = [
+        ("hello", "bonjour"), ("thank you", "merci"), ("good night", "bonne nuit"),
+        ("good morning", "bonjour"), ("i love you", "je t aime"),
+        ("how are you", "comment ca va"), ("see you", "a bientot"),
+        ("yes", "oui"), ("no", "non"), ("please", "s il vous plait"),
+    ]
+    src_texts = [p[0] for p in pairs]
+    tgt_texts = ["\t" + p[1] + "\n" for p in pairs]  # \t = <start>, \n = <end>
+
+    # --- character vocabularies (index 0 reserved for padding) ---
+    src_chars = sorted(set("".join(src_texts)))
+    tgt_chars = sorted(set("".join(tgt_texts)))
+    src2idx = {c: i + 1 for i, c in enumerate(src_chars)}
+    tgt2idx = {c: i + 1 for i, c in enumerate(tgt_chars)}
+    idx2tgt = {i: c for c, i in tgt2idx.items()}
+    src_vocab, tgt_vocab = len(src2idx) + 1, len(tgt2idx) + 1
+
+    max_src = max(len(t) for t in src_texts)
+    max_tgt = max(len(t) for t in tgt_texts)
+
+    def encode(texts, vocab, maxlen):
+        arr = np.zeros((len(texts), maxlen), dtype="int32")
+        for i, t in enumerate(texts):
+            for j, c in enumerate(t):
+                arr[i, j] = vocab[c]
+        return arr
+
+    enc_in = encode(src_texts, src2idx, max_src)
+    tgt_all = encode(tgt_texts, tgt2idx, max_tgt)
+    dec_in = tgt_all[:, :-1]    # teacher forcing input  : <start> w1 w2 ...
+    dec_out = tgt_all[:, 1:]    # expected output        : w1 w2 ... <end>
+
+    latent = 128
+
+    # --- encoder ---
+    enc_inputs = layers.Input(shape=(None,))
+    enc_emb = layers.Embedding(src_vocab, 64, mask_zero=True)(enc_inputs)
+    _, state_h, state_c = layers.LSTM(latent, return_state=True)(enc_emb)
+    enc_states = [state_h, state_c]
+
+    # --- decoder (initial state = encoder's final state) ---
+    dec_inputs = layers.Input(shape=(None,))
+    dec_emb_layer = layers.Embedding(tgt_vocab, 64, mask_zero=True)
+    dec_lstm = layers.LSTM(latent, return_sequences=True, return_state=True)
+    dec_dense = layers.Dense(tgt_vocab, activation="softmax")
+
+    dec_seq, _, _ = dec_lstm(dec_emb_layer(dec_inputs), initial_state=enc_states)
+    dec_probs = dec_dense(dec_seq)
+
+    # --- training model ---
+    model = models.Model([enc_inputs, dec_inputs], dec_probs)
+    model.compile(optimizer="adam", loss="sparse_categorical_crossentropy")
+    model.fit([enc_in, dec_in], dec_out, batch_size=4, epochs=300, verbose=1)
+
+    # --- inference models (reuse trained layers) ---
+    encoder_model = models.Model(enc_inputs, enc_states)
+
+    h_in = layers.Input(shape=(latent,))
+    c_in = layers.Input(shape=(latent,))
+    out, h, c = dec_lstm(dec_emb_layer(dec_inputs), initial_state=[h_in, c_in])
+    decoder_model = models.Model([dec_inputs, h_in, c_in],
+                                 [dec_dense(out), h, c])
+
+    def translate(sentence):
+        x = encode([sentence], src2idx, max_src)
+        h, c = encoder_model.predict(x, verbose=0)
+        token = np.array([[tgt2idx["\t"]]])
+        result = ""
+        for _ in range(max_tgt):
+            probs, h, c = decoder_model.predict([token, h, c], verbose=0)
+            idx = int(np.argmax(probs[0, -1]))      # greedy decoding
+            ch = idx2tgt.get(idx, "")
+            if ch == "\n":
+                break
+            result += ch
+            token = np.array([[idx]])
+        return result
+
+    print("=== Machine translation ===")
+    for s in ["hello", "thank you", "good night", "i love you"]:
+        print(f"{s} -> {translate(s)}")
+machine_translation_demo()
+
+
+
+# =====================================================================
+# 3. POS TAGGING (Bidirectional LSTM, many-to-many)
+# =====================================================================
+def pos_tagging_demo():
+    data = [
+        [("the", "DET"), ("dog", "NOUN"), ("barks", "VERB")],
+        [("a", "DET"), ("cat", "NOUN"), ("sleeps", "VERB")],
+        [("the", "DET"), ("big", "ADJ"), ("dog", "NOUN"), ("runs", "VERB")],
+        [("she", "PRON"), ("reads", "VERB"), ("a", "DET"), ("book", "NOUN")],
+        [("he", "PRON"), ("eats", "VERB"), ("the", "DET"), ("red", "ADJ"), ("apple", "NOUN")],
+        [("the", "DET"), ("small", "ADJ"), ("cat", "NOUN"), ("jumps", "VERB")],
+        [("a", "DET"), ("bird", "NOUN"), ("sings", "VERB")],
+    ]
+
+    # --- vocabularies (0 = PAD, 1 = UNK for words) ---
+    words = sorted({w for s in data for w, _ in s})
+    tags = sorted({t for s in data for _, t in s})
+    word2idx = {w: i + 2 for i, w in enumerate(words)}
+    word2idx["<PAD>"], word2idx["<UNK>"] = 0, 1
+    tag2idx = {t: i + 1 for i, t in enumerate(tags)}
+    tag2idx["<PAD>"] = 0
+    idx2tag = {i: t for t, i in tag2idx.items()}
+
+    max_len = max(len(s) for s in data)
+    X = np.zeros((len(data), max_len), dtype="int32")
+    y = np.zeros((len(data), max_len), dtype="int32")
+    for i, sent in enumerate(data):
+        for j, (w, t) in enumerate(sent):
+            X[i, j] = word2idx[w]
+            y[i, j] = tag2idx[t]
+
+    # --- model: Embedding -> BiLSTM (return_sequences) -> Dense per time step ---
+    model = models.Sequential([
+        layers.Input(shape=(max_len,)),
+        layers.Embedding(len(word2idx), 50, mask_zero=True),
+        layers.Bidirectional(layers.LSTM(64, return_sequences=True)),
+        layers.TimeDistributed(layers.Dense(len(tag2idx), activation="softmax")),
+    ])
+    model.compile(optimizer="adam", loss="sparse_categorical_crossentropy",
+                  metrics=["accuracy"])
+    model.fit(X, y, epochs=100, batch_size=2, verbose=0)
+
+    def tag_sentence(sentence):
+        toks = sentence.lower().split()
+        x = np.zeros((1, max_len), dtype="int32")
+        for j, w in enumerate(toks[:max_len]):
+            x[0, j] = word2idx.get(w, 1)
+        pred = np.argmax(model.predict(x, verbose=0)[0], axis=-1)
+        return [(w, idx2tag[p]) for w, p in zip(toks, pred)]
+
+    print("=== POS tagging ===")
+    print(tag_sentence("the dog sleeps"))
+    print(tag_sentence("she eats a red apple"))
+pos_tagging_demo()
+# Sentiment analysis with an RNN (LSTM) in TensorFlow / Keras
+"""
+Sentiment analysis with an RNN (LSTM) in TensorFlow / Keras
+Dataset : IMDB movie reviews (50,000 reviews, positive / negative)
+Type    : many-to-one  (sequence of words -> single label)
+Requires: pip install tensorflow numpy
+"""
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras import layers, models
+from tensorflow.keras.datasets import imdb
+from tensorflow.keras.preprocessing.sequence import pad_sequences
+
+# ---------------------------------------------------------------
+# 1. Load data (reviews are already converted to word indices)
+# ---------------------------------------------------------------
+VOCAB_SIZE = 10000   # keep the 10,000 most frequent words
+MAX_LEN = 200        # pad / truncate every review to 200 words
+
+(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=VOCAB_SIZE)
+
+x_train = pad_sequences(x_train, maxlen=MAX_LEN, padding="post", truncating="post")
+x_test = pad_sequences(x_test, maxlen=MAX_LEN, padding="post", truncating="post")
+
+print("Train shape:", x_train.shape, "| Test shape:", x_test.shape)
+
+# ---------------------------------------------------------------
+# 2. Build model: Embedding -> Bidirectional LSTM -> Dense(sigmoid)
+# ---------------------------------------------------------------
+model = models.Sequential([
+    layers.Input(shape=(MAX_LEN,)),
+    layers.Embedding(VOCAB_SIZE, 64, mask_zero=True),   # word index -> 64-d vector
+    layers.Bidirectional(layers.LSTM(64)),               # reads text both directions
+    layers.Dropout(0.5),                                 # reduces overfitting
+    layers.Dense(32, activation="relu"),
+    layers.Dense(1, activation="sigmoid"),               # probability of positive
+])
+
+model.compile(
+    loss="binary_crossentropy",
+    optimizer="adam",
+    metrics=["accuracy"],
+)
+model.summary()
+
+# ---------------------------------------------------------------
+# 3. Train
+# ---------------------------------------------------------------
+early_stop = tf.keras.callbacks.EarlyStopping(
+    monitor="val_loss", patience=2, restore_best_weights=True
+)
+
+history = model.fit(
+    x_train, y_train,
+    validation_split=0.2,
+    epochs=10,
+    batch_size=128,
+    callbacks=[early_stop],
+)
+
+# ---------------------------------------------------------------
+# 4. Evaluate
+# ---------------------------------------------------------------
+loss, acc = model.evaluate(x_test, y_test, verbose=0)
+print(f"\nTest accuracy: {acc:.4f}")
+
+# ---------------------------------------------------------------
+# 5. Predict sentiment of your own sentences
+# ---------------------------------------------------------------
+word_index = imdb.get_word_index()
+# Keras reserves 0 = pad, 1 = start, 2 = unknown, so real words are shifted by 3
+word_index = {w: (i + 3) for w, i in word_index.items()}
+
+
+def encode_review(text):
+    tokens = [1]  # start token
+    for w in text.lower().split():
+        idx = word_index.get(w, 2)
+        tokens.append(idx if idx < VOCAB_SIZE else 2)
+    return pad_sequences([tokens], maxlen=MAX_LEN, padding="post", truncating="post")
+
+
+def predict_sentiment(text):
+    prob = float(model.predict(encode_review(text), verbose=0)[0][0])
+    label = "Positive" if prob >= 0.5 else "Negative"
+    print(f"{label} ({prob:.2f}): {text}")
+
+
+predict_sentiment("this movie was fantastic and the acting was brilliant")
+predict_sentiment("terrible plot and very boring waste of time")
+
+# SENTIMENT ANALYSIS - CSV INPUT FILE - MULTIPLE LABELS - SOFTMAX VERSION
+
+import pandas as pd
+from sklearn.model_selection import train_test_split
+
+df = pd.read_csv("reviews.csv")
+
+label_map = {"negative": 0, "neutral": 1, "positive": 2}
+idx_to_label = {v: k for k, v in label_map.items()}
+
+y = df["label"].str.lower().map(label_map).values        # integers 0, 1, 2
+texts = df["text"].astype(str).values
+
+x_train_txt, x_test_txt, y_train, y_test = train_test_split(
+    texts, y, test_size=0.2, random_state=42, stratify=y)
+
+# Convert raw text to padded word-index sequences
+vectorize = layers.TextVectorization(max_tokens=VOCAB_SIZE, output_sequence_length=MAX_LEN)
+vectorize.adapt(x_train_txt)                              # learn vocabulary from training text only
+x_train = vectorize(x_train_txt).numpy()
+x_test = vectorize(x_test_txt).numpy()
+
+#ENCODE REVIEW IS NOT REQUIRED
+
+def predict_sentiment(text):
+    probs = model.predict(vectorize([text]), verbose=0)[0]
+    label = idx_to_label[int(np.argmax(probs))]
+    print(f"{label} ({probs.max():.2f}): {text}")
+
+#MODEL CHANGE IN OUTPUT LAYER - REST MODEL IS ALL SAME
+layers.Dense(3, activation="softmax")      # was: Dense(1, activation="sigmoid")
+
+model.compile(
+    loss="sparse_categorical_crossentropy",   # was: binary_crossentropy
+    optimizer="adam",
+    metrics=["accuracy"],
+)