Upload 26 files

BIN_BUCKET/app_main.py

@@ -0,0 +1,25 @@
+from engine import *
+from engine_extra import *
+import numpy as np
+
+nnr = nn()
+nnc = extra_engine()
+mmc1 = nnr.nnp(2,2,2,2)
+mmc2 = nnc.ext_engine(3,3,3)
+mult_mmc = mmc1*mmc2
+#---------------------------------
+sigma_1 = nnr.nnp(2,2,2,2)
+sigma_2 = nnc.ext_engine(2,2,2)
+sigma_nc = sigma_1**sigma_2
+
+#---------------------------------
+#sigma_opt = sigma_1/sigma_2*sigma_nc**sigma_1+sigma_1+sigma_2*np.pi
+#sigma_opt_2 = np.array([sigma_opt])*np.pi/sigma_opt
+#show = nnr.nnp(2,2,2,2)
+#print('dim:', show)
+#print('mult mmc:', mult_mmc, 'mmc1:', mmc1, 'mmc2:', mmc2)
+#---------------------------------
+
+print('sigma nc:', sigma_nc)
+
+

BIN_BUCKET/engine.py

@@ -0,0 +1,52 @@
+"""
+ENGINE
+=====
+
+Neural Network NN or (nn) engine, tensor calc neural network
+
+Engine NN
+====
+"""
+
+class nn():
+    
+    def nnp(self, x, y, z, n_layer):
+        #---------------------
+
+        x = x
+        y = y
+        z = z
+        n_layer = n_layer
+
+        #-----------------------
+
+        if x == 0:
+            x = 1
+        else:
+            pass
+
+        if y == 0:
+            y = 1
+        else:
+            pass
+
+        if z == 0:
+            z = 1
+        else:
+            pass
+
+        if n_layer == 0:
+            print('L_ERR, Set To 1')
+            n_layer = 1
+        else:
+            pass
+
+        #----------------------
+
+        dim = x*y*z
+        g_layer = dim*n_layer
+
+        #----------------------
+
+        return g_layer
+    

BIN_BUCKET/engine_extra.py

@@ -0,0 +1,13 @@
+class extra_engine():
+    def ext_engine(self, n_layer, fwd_layer, bcw_layer):
+        n_layer = n_layer
+        fwd_layer = fwd_layer
+        bcw_layer = bcw_layer
+        #------------------------
+        mult = n_layer**fwd_layer
+        sum_stg1 = mult+bcw_layer
+        sum_stg2 = fwd_layer*bcw_layer
+        fine_sum = sum_stg1+sum_stg2
+        #----------------------------
+        return fine_sum
+    

basic_python_study/class_std_day1_1.py

@@ -0,0 +1,30 @@
+class Person:
+  def __init__(self, name, age):
+    self.name = name
+    self.age = age
+
+user = Person("John", 36)
+
+print(user.name)
+print(user.age)
+
+#--------------------------------------
+
+class Person2:
+  def __init__(self, name, age):
+    self.name = name
+    self.age = age
+
+  def __str__(self):
+    return f"{self.name}({self.age})"
+
+user2 = Person2("John", 36)
+
+print(user2)
+
+
+
+
+
+
+

basic_python_study/socket_day1_1.py

@@ -0,0 +1,16 @@
+import socket
+
+HOST = ("192.168.1.1")  # Standard loopback interface address (localhost)
+PORT = 65432  # Port to listen on (non-privileged ports are > 1023)
+
+with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+    s.connect(HOST)
+    s.listen()
+    conn, addr = s.accept()
+    with conn:
+        print(f"Connected by {addr}")
+        while True:
+            data = conn.recv(1024)
+            if not data:
+                break
+            conn.sendall(data)

data.csv

@@ -0,0 +1,58 @@
+text,label
+"I love this product! It's amazing.",positive
+"This is the worst purchase I've ever made.",negative
+"Great service and friendly staff.",positive
+"I'm not satisfied with the quality.",negative
+"Absolutely fantastic! Highly recommend it.",positive
+"Terrible experience. Will not buy again.",negative
+"The best investment I've ever made.",positive
+"Very disappointed. It didn't work as expected.",negative
+"I am extremely happy with my purchase!",positive
+"Not worth the money. Very cheap.",negative
+"Excellent quality! Will buy again.",positive
+"Completely useless. A waste of money.",negative
+"I can't believe how good this is!",positive
+"The delivery was late and customer service was unhelpful.",negative
+"I will tell all my friends about this!",positive
+"The product did not meet my expectations.",negative
+"Fantastic! I will definitely return.",positive
+"Poor quality and bad customer support.",negative
+"I was pleasantly surprised by this product.",positive
+"Not impressed, it broke after a week.",negative
+"Five stars! Exceeded my expectations.",positive
+"I would not recommend this to anyone.",negative
+"Very satisfied with my purchase!",positive
+"This is the best I've ever tried.",positive
+"Such a letdown, I expected more.",negative
+"Perfect for what I needed!",positive
+"Terrible quality, do not buy.",negative
+"I'm very pleased with my experience.",positive
+"Will never buy from this company again.",negative
+"Impressive quality and fast shipping!",positive
+"Not what I expected at all.",negative
+"I'm thrilled with the results!",positive
+"Disappointing performance, very slow.",negative
+"I absolutely love it!",positive
+"Would give zero stars if I could.",negative
+"Great value for the price.",positive
+"Awful, I want my money back.",negative
+"Highly satisfied, I will be a returning customer.",positive
+"Really bad service, they didn't care.",negative
+"Such a great find! I'm so happy.",positive
+"Never again, this was a terrible mistake.",negative
+"Fantastic product for the price!",positive
+"Don't waste your time or money.",negative
+"This is my go-to product now!",positive
+"Extremely disappointed, it broke easily.",negative
+"Best purchase of the year!",positive
+"Extremely poor quality, do not recommend.",negative
+"Superb! Exactly what I was looking for.",positive
+"Very frustrating experience, I'm unhappy.",negative
+"I can't get enough of this!",positive
+"Would not recommend this product.",negative
+"I would definitely buy this again!",positive
+"Completely unsatisfactory.",negative
+"Very high quality, I'm impressed!",positive
+"One of the worst purchases I've made.",negative
+"Excellent product! I use it every day.",positive
+"Not worth the hype.",negative

data.txt

@@ -0,0 +1,21 @@
+Once upon a time in a distant land, there was a wise old man who lived in a small village. He had seen many seasons come and go and had gathered wisdom from every experience. 
+
+One day, a young traveler arrived at the village and asked the old man, "What is the secret to happiness?" 
+
+The old man smiled and said, "Happiness is like the wind. You cannot catch it, but you can feel it when you open your heart."
+
+The traveler pondered these words as he continued his journey.
+
+Meanwhile, in another part of the world, a great war was raging. Two kingdoms, locked in battle, sought dominance over the land. But among the soldiers, there was one warrior who questioned the purpose of the war. "Why do we fight?" he asked his commander.
+
+"Because power must be won," the commander replied.
+
+"But at what cost?" the warrior thought.
+
+In a different time and place, a scientist was on the brink of a great discovery. She had spent years studying the stars, hoping to find the answer to humanity’s biggest question: Are we alone?
+
+One night, as she gazed through her telescope, she saw something unusual—a faint signal from a distant galaxy. Was it a message? A call from another world? She recorded her findings and prepared to share them with the world.
+
+The universe is vast, filled with stories waiting to be told. Every moment, a new tale begins.
+
+And so, the story continues...

numpy_study/day1_1.py

@@ -0,0 +1,5 @@
+import numpy as np
+
+out = np.array(1)
+
+print(out)

pytorch_directml/dataloader_classification.py

@@ -0,0 +1,70 @@
+import torch
+import torch_directml
+from torch import nn
+from torch.utils.data import DataLoader
+from torchvision import datasets
+from torchvision.transforms import ToTensor, Lambda, Compose, transforms
+import torchvision.models as models
+import collections
+import matplotlib.pyplot as plt
+import argparse
+import time
+import os
+import pathlib
+
+def get_pytorch_root(path):
+    return pathlib.Path(__file__).parent.parent.resolve()
+
+
+def get_pytorch_data():
+    return str(os.path.join(pathlib.Path(__file__).parent.parent.resolve(), 'data'))
+
+
+def get_data_path(path):
+    if (os.path.isabs(path)):
+        return path
+    else:
+        return str(os.path.join(get_pytorch_data(), path))
+
+
+def print_dataloader(dataloader, mode):
+    for X, y in dataloader:
+        print("\t{} data X [N, C, H, W]: \n\t\tshape={}, \n\t\tdtype={}".format(mode, X.shape, X.dtype))
+        print("\t{} data Y: \n\t\tshape={}, \n\t\tdtype={}".format(mode, y.shape, y.dtype))
+        break
+
+
+def create_training_data_transform(input_size):
+    return transforms.Compose([transforms.RandomResizedCrop(input_size),
+                                          transforms.RandomHorizontalFlip(),
+                                          transforms.ToTensor(),
+                                          transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])
+
+
+def create_training_dataloader(path, batch_size, input_size=224):
+    path = get_data_path(path)
+    print('Loading the training dataset from: {}'.format(path))
+    train_transform = create_training_data_transform(input_size)       
+    training_set = datasets.CIFAR10(root=path, train=True, download=False, transform=train_transform)
+    data_loader = DataLoader(dataset=training_set, batch_size=batch_size, shuffle=True, num_workers=0)
+    print_dataloader(data_loader, 'Train')
+    return data_loader
+
+
+def create_testing_data_transform(input_size):
+    return transforms.Compose([
+        transforms.Resize(256),
+        transforms.CenterCrop(input_size),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+    ])
+
+
+def create_testing_dataloader(path, batch_size, input_size=224):
+    path = get_data_path(path)
+    print('Loading the testing dataset from: {}'.format(path))
+    test_transform = create_testing_data_transform(input_size)
+    test_set = datasets.CIFAR10(root=path, train=False, download=False, transform=test_transform)
+    data_loader = DataLoader(dataset=test_set, batch_size=batch_size, shuffle=False, num_workers=0)
+    print_dataloader(data_loader, 'Test')
+    return data_loader

pytorch_directml/test_classification.py

@@ -0,0 +1,192 @@
+import torch
+import torch_directml
+from torch import nn
+from torch.utils import data
+from torch.utils.data import DataLoader
+from torchvision import datasets
+from torchvision.transforms import ToTensor, Lambda, Compose, transforms
+import torchvision.models as models
+import collections
+import matplotlib.pyplot as plt
+import argparse
+import time
+import os
+import pathlib
+import dataloader_classification
+import torch.autograd.profiler as profiler
+from PIL import Image
+from os.path import exists
+
+def get_checkpoint_folder(model_str, device):
+    device_str = 'dml' if device.type == 'privateuseone' else str(device)
+    checkpoint_folder = str(os.path.join(pathlib.Path(__file__).parent.parent.resolve(),
+                    'checkpoints', model_str, device_str))
+    os.makedirs(checkpoint_folder, exist_ok=True)
+    return str(os.path.join(checkpoint_folder, 'checkpoint.pth'))
+
+def eval(dataloader, model_str, model, device, loss, highest_accuracy, save_model, trace):
+    size = len(dataloader.dataset)
+    num_batches = len(dataloader)
+
+    # Switch model to evaluation mode
+    model.eval()
+
+    test_loss, correct = 0, 0
+    with torch.no_grad():
+        for X, y in dataloader:
+            X = X.to(device)
+            y = y.to(device)
+            
+            # Evaluate the model on the test input
+            if (trace):
+                with profiler.profile(record_shapes=True, with_stack=True, profile_memory=True) as prof:
+                    with profiler.record_function("model_inference"):
+                        pred = model(X)
+                print(prof.key_averages().table(sort_by="cpu_time_total", row_limit=1000))
+                break
+            else:
+                pred = model(X)
+
+            test_loss += loss(pred, y).to("cpu")
+            correct += (pred.to("cpu").argmax(1) == y.to("cpu")).type(torch.float).sum()
+
+    if not trace:
+        test_loss /= num_batches
+        correct /= size
+        
+        if (correct.item() > highest_accuracy):
+            highest_accuracy = correct.item()
+            print("current highest_accuracy: ", highest_accuracy)
+            
+            # save model
+            if save_model:
+                state_dict = collections.OrderedDict()
+                for key in model.state_dict().keys():
+                    state_dict[key] = model.state_dict()[key].to("cpu")
+                checkpoint = get_checkpoint_folder(model_str, device)
+                torch.save(state_dict, checkpoint)
+
+        print(f"Test Error: \n Accuracy: {(100*correct.item()):>0.1f}%, Avg loss: {test_loss.item():>8f} \n")
+
+    return highest_accuracy
+
+
+def get_model(model_str, device):
+    if (model_str == 'squeezenet1_1'):
+        model = models.squeezenet1_1(num_classes=10).to(device)
+    elif (model_str == 'resnet50'):
+        model = models.resnet50(num_classes=10).to(device)
+    elif (model_str == 'squeezenet1_0'):
+        model = models.squeezenet1_0(num_classes=10).to(device)
+    elif (model_str == 'resnet18'):
+        model = models.resnet18(num_classes=10).to(device)
+    elif (model_str == 'alexnet'):
+        model = models.alexnet(num_classes=10).to(device)
+    elif (model_str == 'vgg16'):
+        model = models.vgg16(num_classes=10).to(device)
+    elif (model_str == 'densenet161'):
+        model = models.densenet161(num_classes=10).to(device)
+    elif (model_str == 'inception_v3'):
+        model = models.inception_v3(num_classes=10).to(device)
+    elif (model_str == 'googlenet'):
+        model = models.googlenet(num_classes=10).to(device)
+    elif (model_str == 'shufflenet_v2_x1_0'):
+        model = models.shufflenet_v2_x1_0(num_classes=10).to(device)
+    elif (model_str == 'mobilenet_v2'):
+        model = models.mobilenet_v2(num_classes=10).to(device)
+    elif (model_str == 'mobilenet_v3_large'):
+        model = models.mobilenet_v3_large(num_classes=10).to(device)
+    elif (model_str == 'mobilenet_v3_small'):
+        model = models.mobilenet_v3_small(num_classes=10).to(device)
+    elif (model_str == 'resnext50_32x4d'):
+        model = models.resnext50_32x4d(num_classes=10).to(device)
+    elif (model_str == 'wide_resnet50_2'):
+        model = models.wide_resnet50_2(num_classes=10).to(device)
+    elif (model_str == 'mnasnet1_0'):
+        model = models.mnasnet1_0(num_classes=10).to(device)
+    else:
+        raise Exception(f"Model {model_str} is not supported yet!")
+
+    checkpoint = get_checkpoint_folder(model_str, device)
+    if (exists(checkpoint)):
+        model.load_state_dict(torch.load(checkpoint))
+
+    return model
+
+def preprocess(filename, device, input_size=1):
+    input_image = Image.open(filename)
+    preprocess_transform = dataloader_classification.create_testing_data_transform(input_size)
+    input_tensor = preprocess_transform(input_image)
+    input_batch = input_tensor.unsqueeze(0) # create a mini-batch as expected by the model
+    input_batch = input_batch.to(device)
+    return input_batch
+
+def predict(filename, model_str, device):
+    # Get the model
+    model = get_model(model_str, device)
+    model.eval()
+
+    # Preprocess input
+    input = preprocess(filename, device)
+
+    # Evaluate
+    with torch.no_grad():
+        pred = model(input).to('cpu')
+
+    # The output has unnormalized scores. To get probabilities, you can run a softmax on it.
+    probabilities = torch.nn.functional.softmax(pred[0], dim=0)
+
+    data_folder = dataloader_classification.get_pytorch_data()
+    classes_file = str(os.path.join(data_folder, 'imagenet_classes.txt'))
+    with open(classes_file, "r") as f:
+        categories = [s.strip() for s in f.readlines()]
+        # Show top categories per image
+        top5_prob, top5_catid = torch.topk(probabilities, 5)
+        for i in range(top5_prob.size(0)):
+            print(categories[top5_catid[i]], top5_prob[i].item())
+
+
+def main(path, batch_size, device, model_str, trace):
+    if trace:
+        if model_str == 'inception_v3':
+            batch_size = 3
+        else:
+            batch_size = 1
+            
+    input_size = 299 if model_str == 'inception_v3' else 224
+
+    # Load the dataset
+    testing_dataloader = dataloader_classification.create_testing_dataloader(path, batch_size, input_size)
+
+    # Create the device
+    device = torch.device(device)
+ 
+    # Load the model on the device
+    start = time.time()
+
+    model = get_model(model_str, device)
+
+    print('Finished moving {} to device: {} in {}s.'.format(model_str, device, time.time() - start))
+
+    cross_entropy_loss = nn.CrossEntropyLoss().to(device)
+
+    # Test
+    highest_accuracy = eval(testing_dataloader,
+                            model_str,
+                            model,
+                            device,
+                            cross_entropy_loss,
+                            0,
+                            False,
+                            trace)
+    
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(__doc__)
+    parser.add_argument("--path", type=str, default="cifar-10-python", help="Path to cifar dataset.")
+    parser.add_argument('--batch_size', type=int, default=32, metavar='N', help='Batch size to train with.')
+    parser.add_argument('--device', type=str, default='dml', help='The device to use for training.')
+    parser.add_argument('--model', type=str, default='resnet18', help='The model to use.')
+    args = parser.parse_args()
+    device = torch_directml.device(torch_directml.default_device()) if args.device == 'dml' else torch.device(args.device)
+    main(args.path, args.batch_size, device, args.model())

pytorch_directml/train_classification.py

@@ -0,0 +1,173 @@
+#!/usr/bin/env python
+# Copyright (c) Microsoft Corporation. All rights reserved.
+
+import torch
+import torch_directml
+from torch import nn
+from torch.utils.data import DataLoader
+from torchvision import datasets
+from torchvision.transforms import ToTensor, Lambda, Compose, transforms
+import torchvision.models as models
+import collections
+import matplotlib.pyplot as plt
+import argparse
+import time
+import os
+import pathlib
+import test_classification
+import dataloader_classification
+from test_classification import get_model
+import torch.autograd.profiler as profiler
+
+def select_device(device=''):
+    if device.lower() == 'cuda':
+        if not torch.cuda.is_available():
+            print ("torch.cuda not available")
+            return torch.device('cpu')    
+        else:
+            return torch.device('cuda:0')
+    if device.lower() == 'dml':
+        return torch_directml.device(torch_directml.default_device())
+    else:
+        return torch.device('cpu')
+
+def train(dataloader, model, device, loss, learning_rate, momentum, weight_decay, trace, model_str, ci_train):
+    size = len(dataloader.dataset)
+
+    # Define optimizer
+    optimizer = torch.optim.SGD(
+        model.parameters(),
+        lr=learning_rate,
+        momentum=momentum,
+        weight_decay=weight_decay)
+        
+    optimize_after_batches = 1
+    start = time.time()
+    for batch, (X, y) in enumerate(dataloader):
+        X = X.to(device)
+        y = y.to(device)
+
+        if (trace):
+            with profiler.profile(record_shapes=True, with_stack=True, profile_memory=True) as prof:
+                with profiler.record_function("model_inference"):
+                    # Compute loss and perform backpropagation
+                    if (model_str == 'inception_v3'):
+                        pred, _ = model(X)
+                    elif (model_str == 'googlenet'):
+                        pred, _, _ = model(X)
+                    else:
+                        pred = model(X)
+
+                    batch_loss = loss(pred, y)
+                    batch_loss.backward()
+
+                    if batch % optimize_after_batches == 0:
+                        optimizer.step()
+                        optimizer.zero_grad()
+            print(prof.key_averages().table(sort_by="cpu_time_total", row_limit=1000))
+            break
+        else:
+            # Compute loss and perform backpropagation
+            if (model_str == 'inception_v3'):
+                outputs, aux_outputs = model(X)
+                loss1 = loss(outputs, y)
+                loss2 = loss(aux_outputs, y)
+                batch_loss = loss1 + 0.4*loss2
+            elif (model_str == 'googlenet'):
+                outputs, aux_outputs_1, aux_outputs_2 = model(X)
+                loss1 = loss(outputs, y)
+                loss2 = loss(aux_outputs_1, y)
+                loss3 = loss(aux_outputs_2, y)
+                batch_loss = loss1 + 0.3*loss2 + 0.3*loss3
+            else:
+                pred = model(X)
+                batch_loss = loss(model(X), y)
+            batch_loss.backward()
+
+            if batch % optimize_after_batches == 0:
+                optimizer.step()
+                optimizer.zero_grad()
+            
+        if (batch+1) % 100 == 0:
+            batch_loss_cpu, current = batch_loss.to('cpu'), (batch+1) * len(X)
+            print(f"loss: {batch_loss_cpu.item():>7f}  [{current:>5d}/{size:>5d}] in {time.time() - start:>5f}s")
+            start = time.time()
+
+        if ci_train:
+            print(f"train [{len(X):>5d}/{size:>5d}] in {time.time() - start:>5f}s")
+            break
+
+
+def main(path, batch_size, epochs, learning_rate,
+         momentum, weight_decay, device, model_str, save_model, trace, ci_train=False):
+    if trace:
+        if model_str == 'inception_v3':
+            batch_size = 3
+        else:
+            batch_size = 1
+    epochs = 1 if trace or ci_train else epochs
+    
+    input_size = 299 if model_str == 'inception_v3' else 224
+
+    model = get_model(model_str, device)
+
+    # Load the dataset
+    training_dataloader = dataloader_classification.create_training_dataloader(path, batch_size, input_size)
+    testing_dataloader = dataloader_classification.create_testing_dataloader(path, batch_size, input_size)
+
+    # Load the model on the device
+    start = time.time()
+    
+    print('Finished moving {} to device: {} in {}s.'.format(model_str, device, time.time() - start))
+ 
+    cross_entropy_loss = nn.CrossEntropyLoss().to(device)
+
+    highest_accuracy = 0
+
+    for t in range(epochs):
+        print(f"Epoch {t+1}\n-------------------------------")
+
+        # Train
+        train(training_dataloader,
+              model,
+              device,
+              cross_entropy_loss,
+              learning_rate,
+              momentum,
+              weight_decay,
+              trace,
+              model_str,
+              ci_train)
+
+        if not trace and not ci_train:
+            # Test
+            highest_accuracy = test_classification.eval(testing_dataloader,
+                                    model_str,
+                                    model,
+                                    device,
+                                    cross_entropy_loss,
+                                    highest_accuracy,
+                                    save_model,
+                                    False)
+
+    print("Done! with highest_accuracy: ", highest_accuracy)
+    
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(__doc__)
+    parser.add_argument("--path", type=str, default="cifar-10-python", help="Path to cifar dataset.")
+    parser.add_argument('--batch_size', type=int, default=32, metavar='N', help='Batch size to train with.')
+    parser.add_argument('--epochs', type=int, default=50, metavar='N', help='The number of epochs to train for.')
+    parser.add_argument('--learning_rate', type=float, default=0.001, metavar='LR', help='The learning rate.')
+    parser.add_argument('--momentum', type=float, default=0.9, metavar='M', help='The percentage of past parameters to store.')
+    parser.add_argument('--weight_decay', default=0.0001, type=float, help='The parameter to decay weights.')
+    parser.add_argument('--device', type=str, default='dml', help='The device to use for training.')
+    parser.add_argument('--model', type=str, default='', help='The model to use.')
+    parser.add_argument('--save_model', action='store_true', help='save model state_dict to file')
+    parser.add_argument('--trace', type=bool, default=False, help='Trace performance.')
+    args = parser.parse_args()
+
+    print (args)
+    device = select_device(args.device)
+    main(args.path, args.batch_size, args.epochs, args.learning_rate,
+         args.momentum, args.weight_decay, device, args.model, args.save_model, args.trace)

pytorch_study/day1_1.py

@@ -0,0 +1,19 @@
+import torch as t
+
+import torch.nn as nn
+
+import numpy as np
+
+x = t.tensor(1., requires_grad=True)
+w = t.tensor(2., requires_grad=True)
+b = t.tensor(3., requires_grad=True)
+
+y = w*x+b
+
+y.backward()
+
+
+
+print(x.grad)
+print(w.grad)
+print(b.grad)

pytorch_study/day1_2.py

@@ -0,0 +1,31 @@
+import torch as t
+import torch.nn as nn
+
+x = t.randn(4,3)
+y = t.randn(4,2)
+
+linear = nn.Linear(3,2)
+
+print('w: ', linear.weight)
+print('b: ', linear.bias)
+
+criterion = nn.MSELoss()
+optimizer = t.optim.SGD(linear.parameters(), lr=0.01)
+
+pred = linear(x)
+
+loss = criterion(pred, y)
+print('loss: ', loss.item())
+
+loss.backward()
+
+print('dL/dw: ', linear.weight.grad)
+print('dL/db: ', linear.bias.grad)
+
+
+optimizer.step()
+
+pred = linear(x)
+loss = criterion(pred, y)
+
+print('loss after 1 step optimization', loss.item())

pytorch_study/day2_1.py

@@ -0,0 +1,6 @@
+import torch as t
+
+x = t.tensor([[1,1], [2,2], [3,3], [4,4]])
+y = x.pow(1)
+
+print(y)

pytorch_study/day3_1.py

@@ -0,0 +1,115 @@
+import pandas as pd
+import torch
+import numpy
+import torch.nn as nn
+import torch.optim as optim
+from sklearn.feature_extraction.text import CountVectorizer
+
+#  ۱. داده‌ها را ایجاد و ذخیره کنید
+data = {
+    "text": [
+        "This movie was great",
+        "I did not like this movie",
+        "The acting was terrible",
+        "I loved the plot",
+        "It was a boring experience",
+        "What a fantastic film!",
+        "I hated it",
+        "It was okay",
+        "Absolutely wonderful!",
+        "Not my favorite"
+        "Was very good"
+        "Very good"
+    ],
+    "label": [
+        1,  # Positive
+        0,  # Negative
+        0,  # Negative
+        1,  # Positive
+        0,  # Negative
+        1,  # Positive
+        0,  # Negative
+        0,  # Negative
+        1,  # Positive
+        0,
+        1,
+        1   # Negative
+    ]
+}
+
+# تبدیل دیکشنری به DataFrame و ذخیره در CSV
+df = pd.DataFrame(data)
+df.to_csv("data.csv", index=False)
+
+#  ۲. خواندن و پردازش داده‌ها
+df = pd.read_csv("data.csv")
+
+#  ۳. تبدیل کلمات به اعداد (Tokenization)
+vectorizer = CountVectorizer()
+X = vectorizer.fit_transform(df["text"]).toarray()
+y = df["label"].values
+
+# تبدیل داده‌ها به Tensor
+X_tensor = torch.tensor(X, dtype=torch.float32)
+y_tensor = torch.tensor(y, dtype=torch.float32).view(-1, 1)
+
+#  ۴. ساخت مدل شبکه عصبی
+class SentimentAnalysisModel(nn.Module):
+    def __init__(self, input_size):
+        super(SentimentAnalysisModel, self).__init__()
+        self.fc1 = nn.Linear(input_size, 8)  # لایه‌ی مخفی با ۸ نورون
+        self.fc2 = nn.Linear(8, 1)  # خروجی (یک مقدار بین ۰ و ۱)
+        self.relu = nn.ReLU()  # تابع فعال‌ساز
+
+    def forward(self, x):
+        x = self.relu(self.fc1(x))
+        x = torch.sigmoid(self.fc2(x))  # تابع سیگموید برای خروجی بین ۰ و ۱
+        return x
+
+#  ۵. تنظیم تابع هزینه و بهینه‌ساز
+input_size = X.shape[1]  # تعداد ویژگی‌ها (کلمات منحصر به فرد)
+model = SentimentAnalysisModel(input_size)
+
+criterion = nn.BCELoss()  # تابع هزینه برای دسته‌بندی دودویی
+optimizer = optim.Adam(model.parameters(), lr=0.01)  # نرخ یادگیری ۰.۰۱
+
+#  ۶. آموزش مدل
+epochs = 100  
+
+for epoch in range(epochs):
+    # ۱. پیش‌بینی مدل
+    y_pred = model(X_tensor)
+    
+    # ۲. محاسبه‌ی هزینه (Loss)
+    loss = criterion(y_pred, y_tensor)
+    
+    # ۳. پاک کردن گرادیان‌های قبلی
+    optimizer.zero_grad()
+    
+    # ۴. محاسبه‌ی گرادیان‌ها و بروزرسانی وزن‌ها
+    loss.backward()
+    optimizer.step()
+
+    # ۵. نمایش میزان خطا هر ۱۰ مرحله
+    if (epoch+1) % 10 == 0:
+        print(f"Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}")
+
+#  ۷. تست مدل
+def predict_sentiment(text):
+    # تبدیل متن ورودی به بردار ویژگی‌ها
+    text_vectorized = vectorizer.transform([text]).toarray()
+    text_tensor = torch.tensor(text_vectorized, dtype=torch.float32)
+    
+    # پیش‌بینی مدل
+    output = model(text_tensor)
+    
+    # تبدیل مقدار خروجی به برچسب ۰ یا ۱
+    prediction = 1 if output.item() > 0.5 else 0
+    
+    return "Positive" if prediction == 1 else "Negative"
+
+# 🔹 تست روی چند جمله جدید
+print(predict_sentiment("I really enjoyed this movie!"))
+print(predict_sentiment("This was the worst experience ever."))
+print(predict_sentiment("It was just okay, nothing special."))
+print(predict_sentiment("Absolutely loved the storyline!"))

pytorch_study/day3_2.py

@@ -0,0 +1,107 @@
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import LabelEncoder
+from sklearn.feature_extraction.text import CountVectorizer
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from sklearn.metrics import accuracy_score, classification_report
+
+# 1. Load data
+data = pd.read_csv('data.csv')  # Replace 'data.csv' with your dataset
+print("Columns in the dataset:", data.columns)  # Check column names
+
+# 2. Preprocess data
+X = data['text']  # Assuming your text column is named 'text'
+y = data['label']  # Assuming your label column is named 'label'
+
+# Encode labels
+label_encoder = LabelEncoder()
+y_encoded = label_encoder.fit_transform(y)
+
+# Split data into training and testing sets
+X_train, X_test, y_train, y_test = train_test_split(X, y_encoded, test_size=0.2, random_state=42)
+
+# Convert text to numerical features
+vectorizer = CountVectorizer()
+X_train_vectorized = vectorizer.fit_transform(X_train)
+X_test_vectorized = vectorizer.transform(X_test)
+
+# 3. Define the neural network model
+class SentimentModel(nn.Module):
+    def __init__(self, input_size, hidden_size, output_size):
+        super(SentimentModel, self).__init__()
+        self.fc1 = nn.Linear(input_size, hidden_size)
+        self.relu = nn.ReLU()
+        self.fc2 = nn.Linear(hidden_size, output_size)
+        
+    def forward(self, x):
+        x = self.fc1(x)
+        x = self.relu(x)
+        x = self.fc2(x)
+        return x
+
+# Initialize model
+input_size = X_train_vectorized.shape[1]
+hidden_size = 512
+output_size = len(label_encoder.classes_)
+model = SentimentModel(input_size, hidden_size, output_size)
+
+# 4. Define loss function and optimizer
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.Adam(model.parameters(), lr=0.001)
+
+# 5. Train the model
+num_epochs = 1000
+for epoch in range(num_epochs):
+    model.train()
+    optimizer.zero_grad()
+    outputs = model(torch.FloatTensor(X_train_vectorized.toarray()))
+    loss = criterion(outputs, torch.LongTensor(y_train))
+    loss.backward()
+    optimizer.step()
+    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')
+
+# 6. Evaluate the model
+model.eval()
+with torch.no_grad():
+    test_outputs = model(torch.FloatTensor(X_test_vectorized.toarray()))
+    _, predicted = torch.max(test_outputs, 1)
+
+    # Calculate accuracy
+    accuracy = accuracy_score(y_test, predicted.numpy())
+    print(f'Accuracy: {accuracy:.4f}')
+    
+    # Detailed classification report
+    print(classification_report(y_test, predicted.numpy(), target_names=label_encoder.classes_))
+
+# 7. Test the model with new sample inputs
+def predict_sentiment(text):
+    # Vectorize the input text
+    text_vectorized = vectorizer.transform([text])
+    with torch.no_grad():
+        output = model(torch.FloatTensor(text_vectorized.toarray()))
+        _, predicted = torch.max(output, 1)
+        return label_encoder.inverse_transform(predicted.numpy())[0]
+
+# Test the model with new sentences
+new_samples = [
+    "It is very good",
+    "Bad",
+    "Good",
+    "loving you",
+    "Loving you",
+    "love you",
+    "Love you",
+    "Very bad",
+    "I love you",
+    "Fuck",
+    "fuck",
+    "bad store",
+    "i dont love this",
+    "not like this"
+]
+
+for sample in new_samples:
+    sentiment = predict_sentiment(sample)
+    print(f'Text: "{sample}" -> Predicted Sentiment: {sentiment}')

pytorch_study/day3_3.py

@@ -0,0 +1,100 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import numpy as np
+import random
+# خواندن داده‌ها از فایل
+with open("data.txt", "r", encoding="utf-8") as f:
+    text = f.read()
+
+# ایجاد دیکشنری برای تبدیل کاراکترها به اندیس و برعکس
+chars = sorted(list(set(text)))
+char_to_idx = {ch: i for i, ch in enumerate(chars)}
+idx_to_char = {i: ch for i, ch in enumerate(chars)}
+
+# تبدیل متن به لیست از اندیس‌ها
+data = [char_to_idx[ch] for ch in text]
+
+# تنظیم پارامترهای آموزشی
+seq_length = 50  # طول دنباله ورودی
+batch_size = 64
+hidden_size = 128
+num_layers = 2
+num_epochs = 100
+learning_rate = 0.01
+class TextDataset(torch.utils.data.Dataset):
+    def __init__(self, data, seq_length):
+        self.data = data
+        self.seq_length = seq_length
+    
+    def __len__(self):
+        return len(self.data) - self.seq_length
+    
+    def __getitem__(self, idx):
+        return (
+            torch.tensor(self.data[idx:idx+self.seq_length], dtype=torch.long),
+            torch.tensor(self.data[idx+1:idx+self.seq_length+1], dtype=torch.long)
+        )
+
+dataset = TextDataset(data, seq_length)
+dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True)
+class LSTMModel(nn.Module):
+    def __init__(self, vocab_size, hidden_size, num_layers):
+        super(LSTMModel, self).__init__()
+        self.embedding = nn.Embedding(vocab_size, hidden_size)
+        self.lstm = nn.LSTM(hidden_size, hidden_size, num_layers, batch_first=True)
+        self.fc = nn.Linear(hidden_size, vocab_size)
+
+    def forward(self, x, hidden=None):
+        x = self.embedding(x)
+        output, hidden = self.lstm(x, hidden)
+        output = self.fc(output)
+        return output, hidden
+
+vocab_size = len(chars)
+model = LSTMModel(vocab_size, hidden_size, num_layers)
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.Adam(model.parameters(), lr=learning_rate)
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+model.to(device)
+
+for epoch in range(num_epochs):
+    hidden = None  # مقدار اولیه hidden
+
+    for inputs, targets in dataloader:
+        inputs, targets = inputs.to(device), targets.to(device)
+        optimizer.zero_grad()
+
+        # Forward pass
+        outputs, hidden = model(inputs, hidden)
+
+        # Detach hidden state to avoid graph dependency issues
+        hidden = (hidden[0].detach(), hidden[1].detach())
+
+        # Compute loss
+        loss = criterion(outputs.view(-1, vocab_size), targets.view(-1))
+
+        # Backpropagation
+        loss.backward()
+        optimizer.step()
+
+    print(f"Epoch {epoch+1}/{num_epochs}, Loss: {loss.item():.4f}")
+
+    print(f"Epoch {epoch+1}/{num_epochs}, Loss: {total_loss / len(dataloader):.4f}")
+def generate_text(model, start_text, length=200):
+    model.eval()
+    input_seq = torch.tensor([char_to_idx[ch] for ch in start_text], dtype=torch.long).unsqueeze(0).to(device)
+    hidden = None
+    generated_text = start_text
+
+    for _ in range(length):
+        output, hidden = model(input_seq, hidden)
+        next_char_idx = torch.argmax(output[:, -1, :]).item()
+        generated_text += idx_to_char[next_char_idx]
+        input_seq = torch.cat([input_seq[:, 1:], torch.tensor([[next_char_idx]], dtype=torch.long).to(device)], dim=1)
+
+    return generated_text
+
+# تست تولید متن
+start_text = "Once upon a time"
+print(generate_text(model, start_text, 200))

pytorch_study/day4_1.py

@@ -0,0 +1,26 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+class simple_sd_model (nn.Module):
+    def __init__(self):
+        super(simple_sd_model, self).__init__()
+        self.fc1 = nn.Linear (1,1)
+        self.fc2 = nn.Linear (1,6)
+        self.fc3 = nn.Linear (6,7)
+        self.fc4 = nn.Linear (7,4)
+
+    def forward(self, x):
+        x = F.relu (self.fc1(x))
+        x = F.relu (self.fc2(x))
+        x = self.fc3(x)
+        x = self.fc4(x)
+        return x
+
+model = simple_sd_model()
+input_data = torch.rand (10, 1, requires_grad= True)
+output_data = model(input_data)
+print (output_data)
+
+
+
+

pytorch_study/day4_2.py

@@ -0,0 +1,45 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+
+# ⚡ 1. تعریف شبکه عصبی
+class SimpleNN(nn.Module):
+    def __init__(self, input_size, hidden_size, output_size):
+        super(SimpleNN, self).__init__()
+        self.hidden = nn.Linear(input_size, hidden_size)  # لایه پنهان
+        self.activation = nn.ReLU()  # تابع فعال‌سازی
+        self.output = nn.Linear(hidden_size, output_size)  # لایه خروجی
+
+    def forward(self, x):
+        x = self.hidden(x)
+        x = self.activation(x)
+        x = self.output(x)
+        return x
+
+# ⚡ 2. تنظیمات مدل
+input_size = 10   # تعداد ویژگی‌های ورودی (مثلاً 4 ویژگی برای هر داده)
+hidden_size = 4 # تعداد نورون‌های لایه پنهان
+output_size = 4  # تعداد کلاس‌ها (مثلاً 3 کلاس)
+
+model = SimpleNN(input_size, hidden_size, output_size)
+print(model)
+
+# ⚡ 3. تعریف تابع هزینه و بهینه‌ساز
+criterion = nn.CrossEntropyLoss()  # مناسب برای مسائل طبقه‌بندی
+optimizer = optim.Adam(model.parameters(), lr=0.01)  # الگوریتم بهینه‌سازی
+
+# ⚡ 4. داده‌های ورودی ساختگی
+X_train = torch.rand(10, input_size)  # 5 نمونه، هر نمونه دارای 4 ویژگی
+y_train = torch.tensor([0, 1, 2, 1, 0, 1, 2, 1, 0, 1])  # برچسب‌های کلاس (0، 1 یا 2)
+
+# ⚡ 5. آموزش مدل (یک epoch برای مثال)
+for i in range(1):
+    optimizer.zero_grad()  # تنظیم گرادیان‌ها به صفر
+    outputs = model(X_train)  # عبور داده‌ها از شبکه
+    loss = criterion(outputs, y_train)  # محاسبه خطا
+    loss.backward()  # محاسبه گرادیان‌ها
+    optimizer.step()  # بروزرسانی وزن‌ها
+
+# ⚡ 6. نمایش خروجی و خطا
+print(f"Output:\n{outputs}")
+print(f"Loss: {loss.item()}")

pytorch_study/day5_1.py

@@ -0,0 +1,28 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+
+class neural_network (nn.Module):
+    def __init__(self, input_dim, hidden_dim, output_dim):
+        super(neural_network, self).__init__()
+        self.hidden = nn.Linear (input_dim, hidden_dim)
+        self.act = nn.ReLU()
+        self.output = nn.Linear (hidden_dim, output_dim)
+
+    def forward (self, x):
+        x = self.hidden (x)
+        x = self.act (x)
+        x = self.output (x)
+        return x
+
+
+input_dim = 4
+hidden_dim = 32
+output_dim = 4
+
+model = neural_network(input_dim, hidden_dim, output_dim)
+print(model)
+
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.Adam(model.parameters(), lr= 0.01)

simple_gui_find_largfiles/script.py

@@ -0,0 +1,62 @@
+import tkinter as tk
+from tkinter import filedialog, messagebox
+from pathlib import Path
+import os
+
+class LargeFileFinder:
+    def __init__(self, root):
+        self.root = root
+        self.root.title("Large File Finder")
+
+        # Size selection
+        size_label = tk.Label(self.root, text="Select File Size:")
+        size_label.pack()
+
+        self.size_entry = tk.Entry(self.root, width=100)
+        self.size_entry.pack()
+
+        # Find button
+        find_button = tk.Button(self.root, text="Find Large Files", command=self.find_large_files)
+        find_button.pack()
+
+        # Results label
+        self.result_label = tk.Label(self.root, text="Results will appear here", wraplength=400)
+        self.result_label.pack()
+
+    def find_large_files(self):
+        directory = filedialog.askdirectory()
+        if not directory:
+            return
+
+        file_size = self.size_entry.get()
+        if not file_size:
+            messagebox.showwarning("Warning", "Please enter a file size.")
+            return
+
+        try:
+            size_in_bytes = float(file_size)
+        except ValueError:
+            messagebox.showwarning("Warning", "Invalid file size format.")
+            return
+
+        self.result_label.config(text="Searching for large files...")
+
+        results = self.get_large_files(directory, size_in_bytes)
+
+        if results:
+            self.result_label.config(text="Found large files:\n" + results)
+        else:
+            self.result_label.config(text="No large files found.")
+
+def get_large_files(self, directory, size):
+    large_files = []
+    for path in Path(directory).iterdir():
+        if path.is_file() and path.stat().st_size > size:
+            large_files.append(path.as_posix())
+    return "\n".join(large_files)
+
+
+if __name__ == "__main__":
+    root = tk.Tk()
+    LargeFileFinder(root)
+    root.mainloop()