Abien Fred Agarap AFAgarap

## autoencoder-pytorch.ipynb

      
              1 file
            
          
              7 forks
            
          
              8 comments
            
          
              24 stars
            
          
                AFAgarap
                / autoencoder-pytorch.ipynb
            
            
              Last active
              April 28, 2024 12:30
            
              
                PyTorch implementation of an autoencoder.
              
          
      Sorry, something went wrong. Reload?
      Sorry, we cannot display this file.
      Sorry, this file is invalid so it cannot be displayed.
      
          Viewer requires iframe.
      
    
## polynomial-least-squares.py
# Copyright 2017 Abien Fred Agarap. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,

## load_mnist.py
transform = torchvision.transforms.Compose([torchvision.transforms.ToTensor()])

train_dataset = torchvision.datasets.MNIST(
    root="~/torch_datasets", train=True, transform=transform, download=True
)

test_dataset = torchvision.datasets.MNIST(
    root="~/torch_datasets", train=False, transform=transform, download=True
)

## paging.py
#!/usr/bin/env python3
# Paging, a memory management scheme in operating systems
# Author: A.F. Agarap

def main():
	page_mapping = []
	physical_frame_table = []
	virtual_page_table = []

	size = int(input("How many words will you enter? "))

## autoencoder-full.py
"""TensorFlow 2.0 implementation of vanilla Autoencoder."""
import numpy as np
import tensorflow as tf

__author__ = "Abien Fred Agarap"

np.random.seed(1)
tf.random.set_seed(1)
batch_size = 128
epochs = 10

## autoencoder.py
class AE(nn.Module):
    def __init__(self, **kwargs):
        super().__init__()
        self.encoder_hidden_layer = nn.Linear(
            in_features=kwargs["input_shape"], out_features=128
        )
        self.encoder_output_layer = nn.Linear(
            in_features=128, out_features=128
        )
        self.decoder_hidden_layer = nn.Linear(

## train_ae.py
for epoch in range(epochs):
    loss = 0
    for batch_features, _ in train_loader:
        # reshape mini-batch data to [N, 784] matrix
        # load it to the active device
        batch_features = batch_features.view(-1, 784).to(device)

        # reset the gradients back to zero
        # PyTorch accumulates gradients on subsequent backward passes
        optimizer.zero_grad()

## vae.py
class VariationalAutoencoder(tf.keras.Model):
  def __init__(self, latent_dim, original_dim):
    super(VariationalAutoencoder, self).__init__()
    self.encoder = Encoder(latent_dim=latent_dim)
    self.decoder = Decoder(original_dim=original_dim)

  def call(self, input_features):
    z_mean, z_log_var, latent_code = self.encoder(input_features)
    reconstructed = self.decoder(latent_code)
    kl_divergence = -5e-2 * tf.reduce_sum(tf.exp(z_log_var) + tf.square(z_mean) - 1 - z_log_var)

## instantiate_objects.py
#  use gpu if available
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# create a model from `AE` autoencoder class
# load it to the specified device, either gpu or cpu
model = AE(input_shape=784).to(device)

# create an optimizer object
# Adam optimizer with learning rate 1e-3
optimizer = optim.Adam(model.parameters(), lr=1e-3)

## compute_trust_score.py
from trustscore import TrustScore

ts = TrustScore(alpha=5e-2)
ts.fit(encoded_train_features, train_labels)
trust_score, closest_class_not_predicted = ts.score(
  encoded_test_features, predictions, k=5
)
	# Copyright 2017 Abien Fred Agarap. All Rights Reserved.
	#
	# Licensed under the Apache License, Version 2.0 (the "License");
	# you may not use this file except in compliance with the License.
	# You may obtain a copy of the License at
	#
	# http://www.apache.org/licenses/LICENSE-2.0
	#
	# Unless required by applicable law or agreed to in writing, software
	# distributed under the License is distributed on an "AS IS" BASIS,
	transform = torchvision.transforms.Compose([torchvision.transforms.ToTensor()])

	train_dataset = torchvision.datasets.MNIST(
	root="~/torch_datasets", train=True, transform=transform, download=True
	)

	test_dataset = torchvision.datasets.MNIST(
	root="~/torch_datasets", train=False, transform=transform, download=True
	)
	#!/usr/bin/env python3
	# Paging, a memory management scheme in operating systems
	# Author: A.F. Agarap

	def main():
	page_mapping = []
	physical_frame_table = []
	virtual_page_table = []

	size = int(input("How many words will you enter? "))
	"""TensorFlow 2.0 implementation of vanilla Autoencoder."""
	import numpy as np
	import tensorflow as tf

	__author__ = "Abien Fred Agarap"

	np.random.seed(1)
	tf.random.set_seed(1)
	batch_size = 128
	epochs = 10
	class AE(nn.Module):
	def __init__(self, **kwargs):
	super().__init__()
	self.encoder_hidden_layer = nn.Linear(
	in_features=kwargs["input_shape"], out_features=128
	)
	self.encoder_output_layer = nn.Linear(
	in_features=128, out_features=128
	)
	self.decoder_hidden_layer = nn.Linear(
	for epoch in range(epochs):
	loss = 0
	for batch_features, _ in train_loader:
	# reshape mini-batch data to [N, 784] matrix
	# load it to the active device
	batch_features = batch_features.view(-1, 784).to(device)

	# reset the gradients back to zero
	# PyTorch accumulates gradients on subsequent backward passes
	optimizer.zero_grad()
	class VariationalAutoencoder(tf.keras.Model):
	def __init__(self, latent_dim, original_dim):
	super(VariationalAutoencoder, self).__init__()
	self.encoder = Encoder(latent_dim=latent_dim)
	self.decoder = Decoder(original_dim=original_dim)

	def call(self, input_features):
	z_mean, z_log_var, latent_code = self.encoder(input_features)
	reconstructed = self.decoder(latent_code)
	kl_divergence = -5e-2 * tf.reduce_sum(tf.exp(z_log_var) + tf.square(z_mean) - 1 - z_log_var)
	# use gpu if available
	device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

	# create a model from `AE` autoencoder class
	# load it to the specified device, either gpu or cpu
	model = AE(input_shape=784).to(device)

	# create an optimizer object
	# Adam optimizer with learning rate 1e-3
	optimizer = optim.Adam(model.parameters(), lr=1e-3)
	from trustscore import TrustScore

	ts = TrustScore(alpha=5e-2)
	ts.fit(encoded_train_features, train_labels)
	trust_score, closest_class_not_predicted = ts.score(
	encoded_test_features, predictions, k=5
	)