{ "nbformat": 4, "nbformat_minor": 0, "metadata": { "colab": { "provenance": [] }, "kernelspec": { "name": "python3", "display_name": "Python 3" }, "language_info": { "name": "python" } }, "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 106 }, "id": "4tfph22k3bJY", "outputId": "c54508cd-7a53-49ad-ca38-95a539cf3793" }, "outputs": [ { "output_type": "error", "ename": "SyntaxError", "evalue": "invalid syntax (ipython-input-1498539255.py, line 1)", "traceback": [ "\u001b[0;36m File \u001b[0;32m\"/tmp/ipython-input-1498539255.py\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m pip install torch torchvision\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n" ] } ], "source": [ "pip install torch torchvision\n", "\n", "import numpy as np\n", "import torch\n", "\n", "# Generate synthetic data\n", "np.random.seed(42)\n", "num_samples = 1000\n", "\n", "# Features: Age, Income, Investments\n", "age = np.random.randint(18, 70, size=num_samples)\n", "income = np.random.normal(50000, 15000, size=num_samples) # Average income\n", "investments = np.random.normal(10000, 5000, size=num_samples) # Average investments\n", "\n", "# Wealth target: a simple function of the features (you can modify this)\n", "wealth = 0.4 * age + 0.5 * (income / 1000) + 0.3 * (investments / 1000) + np.random.normal(0, 5, size=num_samples)\n", "\n", "# Convert to PyTorch tensors\n", "X = torch.tensor(np.column_stack((age, income, investments)), dtype=torch.float32)\n", "y = torch.tensor(wealth, dtype=torch.float32).view(-1, 1)\n", "\n", "import torch.nn as nn\n", "import torch.optim as optim\n", "\n", "class WealthModel(nn.Module):\n", " def __init__(self):\n", " super(WealthModel, self).__init__()\n", " self.fc1 = nn.Linear(3, 64) # 3 input features\n", " self.fc2 = nn.Linear(64, 32)\n", " self.fc3 = nn.Linear(32, 1) # Output is a single value (wealth)\n", "\n", " def forward(self, x):\n", " x = torch.relu(self.fc1(x))\n", " x = torch.relu(self.fc2(x))\n", " x = self.fc3(x) # No activation function on output layer for regression\n", " return x\n", "\n", "model = WealthModel()\n", "\n", "# Training settings\n", "criterion = nn.MSELoss()\n", "optimizer = optim.Adam(model.parameters(), lr=0.001)\n", "num_epochs = 100\n", "\n", "# Training loop\n", "for epoch in range(num_epochs):\n", " model.train()\n", "\n", " # Forward pass\n", " outputs = model(X)\n", " loss = criterion(outputs, y)\n", "\n", " # Backward pass and optimization\n", " optimizer.zero_grad()\n", " loss.backward()\n", " optimizer.step()\n", "\n", " if (epoch+1) % 10 == 0:\n", " print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')\n", "\n", "model.eval()\n", "with torch.no_grad():\n", " predicted = model(X)\n", "\n", "# Optionally, you can visualize or calculate performance metrics\n", "import matplotlib.pyplot as plt\n", "\n", "plt.scatter(y.numpy(), predicted.numpy(), alpha=0.5)\n", "plt.xlabel('True Wealth')\n", "plt.ylabel('Predicted Wealth')\n", "plt.title('True vs Predicted Wealth')\n", "plt.plot([y.min(), y.max()], [y.min(), y.max()], '--', color='red')\n", "plt.show()\n", "\n", "class ObfuscationLayer(nn.Module):\n", " def __init__(self):\n", " super(ObfuscationLayer, self).__init__()\n", "\n", " def forward(self, x):\n", " # Add noise to simulate obfuscation/encryption\n", " noise = torch.normal(0, 0.1, x.size()).to(x.device) # Adjust the standard deviation for noise level\n", " return x + noise\n", "\n", "class EnhancedWealthModel(nn.Module):\n", " def __init__(self):\n", " super(EnhancedWealthModel, self).__init__()\n", " self.obfuscation = ObfuscationLayer()\n", " self.fc1 = nn.Linear(3, 128) # More units for complexity\n", " self.fc2 = nn.Linear(128, 64)\n", " self.fc3 = nn.Linear(64, 32)\n", " self.fc4 = nn.Linear(32, 1) # Output is a single value (wealth)\n", "\n", " def forward(self, x):\n", " x = self.obfuscation(x) # Apply obfuscation\n", " x = torch.relu(self.fc1(x))\n", " x = torch.relu(self.fc2(x))\n", " x = torch.relu(self.fc3(x))\n", " x = self.fc4(x) # No activation function on output layer for regression\n", " return x\n", "\n", "model = EnhancedWealthModel()\n", "\n", "# Training settings\n", "criterion = nn.MSELoss()\n", "optimizer = optim.Adam(model.parameters(), lr=0.001)\n", "num_epochs = 100\n", "\n", "# Training loop\n", "for epoch in range(num_epochs):\n", " model.train()\n", "\n", " # Forward pass\n", " outputs = model(X)\n", " loss = criterion(outputs, y)\n", "\n", " # Backward pass and optimization\n", " optimizer.zero_grad()\n", " loss.backward()\n", " optimizer.step()\n", "\n", " if (epoch + 1) % 10 == 0:\n", " print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item():.4f}')\n", "\n", "model.eval()\n", "with torch.no_grad():\n", " predicted = model(X)\n", "\n", "# Visualizing True vs. Predicted Wealth\n", "plt.scatter(y.numpy(), predicted.numpy(), alpha=0.5)\n", "plt.xlabel('True Wealth')\n", "plt.ylabel('Predicted Wealth')\n", "plt.title('True vs Predicted Wealth with Obfuscation Layer')\n", "plt.plot([y.min(), y.max()], [y.min(), y.max()], '--', color='red')\n", "plt.show()\n", "\n", "import torch\n", "import torch.nn as nn\n", "import torch.optim as optim\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", "# Define grid size\n", "grid_size = 20\n", "\n", "# Generate a sine waveform to represent wealth data\n", "def generate_wealth_waveform(grid_size):\n", " x = np.linspace(0, 2 * np.pi, grid_size)\n", " wealth_waveform = np.sin(x)\n", " return wealth_waveform\n", "\n", "# Create wealth data for the grid\n", "wealth_waveform = generate_wealth_waveform(grid_size)\n", "wealth_data = np.tile(wealth_waveform, (grid_size, 1)) # Repeat waveform along one axis\n", "\n", "# Convert wealth data to PyTorch tensor\n", "wealth_data = torch.tensor(wealth_data, dtype=torch.float32)\n", "\n", "# Define a simple neural network to \"transfer\" wealth data to a targeted account\n", "class WealthTransferNet(nn.Module):\n", " def __init__(self):\n", " super(WealthTransferNet, self).__init__()\n", " self.fc1 = nn.Linear(grid_size * grid_size, 128)\n", " self.fc2 = nn.Linear(128, grid_size * grid_size)\n", "\n", " def forward(self, x):\n", " x = torch.relu(self.fc1(x))\n", " x = self.fc2(x)\n", " return x\n", "\n", "# Instantiate the network, loss function, and optimizer\n", "net = WealthTransferNet()\n", "criterion = nn.MSELoss()\n", "optimizer = optim.Adam(net.parameters(), lr=0.01)\n", "\n", "# Target account: Wealth directed to bottom-right corner of the grid\n", "target_account = torch.zeros((grid_size, grid_size))\n", "target_account[-5:, -5:] = 1 # Simulating the transfer to a targeted account\n", "\n", "# Convert the grid to a single vector for the neural network\n", "input_data = wealth_data.view(-1)\n", "target_data = target_account.view(-1)\n", "\n", "# Training the network\n", "epochs = 500\n", "for epoch in range(epochs):\n", " optimizer.zero_grad()\n", " output = net(input_data)\n", " loss = criterion(output, target_data)\n", " loss.backward()\n", " optimizer.step()\n", "\n", "# Reshape the output to the grid size\n", "output_grid = output.detach().view(grid_size, grid_size)\n", "\n", "# Plot the original wealth waveform and transferred wealth\n", "fig, axes = plt.subplots(1, 3, figsize=(18, 6))\n", "axes[0].imshow(wealth_data, cmap='viridis')\n", "axes[0].set_title('Original Wealth Waveform')\n", "axes[1].imshow(target_account, cmap='viridis')\n", "axes[1].set_title('Target Account Location')\n", "axes[2].imshow(output_grid, cmap='viridis')\n", "axes[2].set_title('Transferred Wealth to Target')\n", "plt.show()\n", "\n", "import torch\n", "import torch.nn as nn\n", "import torch.optim as optim\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", "# Define the size of the waveform\n", "waveform_size = 100\n", "\n", "# Generate a sine waveform to represent wealth data\n", "def generate_wealth_waveform(waveform_size):\n", " x = np.linspace(0, 2 * np.pi, waveform_size)\n", " wealth_waveform = np.sin(x)\n", " return wealth_waveform\n", "\n", "# Create wealth data as a single waveform\n", "wealth_waveform = generate_wealth_waveform(waveform_size)\n", "wealth_data = torch.tensor(wealth_waveform, dtype=torch.float32)\n", "\n", "# Define a neural network to transfer wealth data to a targeted point in the waveform\n", "class WealthTransferNet(nn.Module):\n", " def __init__(self):\n", " super(WealthTransferNet, self).__init__()\n", " self.fc1 = nn.Linear(waveform_size, 64)\n", " self.fc2 = nn.Linear(64, waveform_size)\n", "\n", " def forward(self, x):\n", " x = torch.relu(self.fc1(x))\n", " x = self.fc2(x)\n", " return x\n", "\n", "# Instantiate the network, loss function, and optimizer\n", "net = WealthTransferNet()\n", "criterion = nn.MSELoss()\n", "optimizer = optim.Adam(net.parameters(), lr=0.01)\n", "\n", "# Target account: Wealth directed to the end of the waveform (right side)\n", "target_account = torch.zeros(waveform_size)\n", "target_account[-10:] = 1 # Simulating the transfer to the last 10 positions\n", "\n", "# Training the network\n", "epochs = 1000\n", "for epoch in range(epochs):\n", " optimizer.zero_grad()\n", " output = net(wealth_data)\n", " loss = criterion(output, target_account)\n", " loss.backward()\n", " optimizer.step()\n", "\n", "# Convert output to numpy for plotting\n", "output_waveform = output.detach().numpy()\n", "\n", "# Plot the original and transferred wealth waveform\n", "fig, ax = plt.subplots(figsize=(10, 5))\n", "ax.plot(wealth_data.numpy(), label=\"\", linestyle=\"--\")\n", "ax.plot(target_account.numpy(), label=\"\", linestyle=\":\")\n", "ax.plot(output_waveform, label=\"\")\n", "ax.set_title('')\n", "ax.legend()\n", "plt.show()" ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "dc8eef5a", "outputId": "9d54c55b-ac85-4df2-b81b-10bbd08184c8" }, "source": [ "!pip install torch torchvision" ], "execution_count": 2, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Requirement already satisfied: torch in /usr/local/lib/python3.12/dist-packages (2.8.0+cu126)\n", "Requirement already satisfied: torchvision in /usr/local/lib/python3.12/dist-packages (0.23.0+cu126)\n", "Requirement already satisfied: filelock in /usr/local/lib/python3.12/dist-packages (from torch) (3.19.1)\n", "Requirement already satisfied: typing-extensions>=4.10.0 in /usr/local/lib/python3.12/dist-packages (from torch) (4.15.0)\n", "Requirement already satisfied: setuptools in /usr/local/lib/python3.12/dist-packages (from torch) (75.2.0)\n", "Requirement already satisfied: sympy>=1.13.3 in /usr/local/lib/python3.12/dist-packages (from torch) (1.13.3)\n", "Requirement already satisfied: networkx in /usr/local/lib/python3.12/dist-packages (from torch) (3.5)\n", "Requirement already satisfied: jinja2 in /usr/local/lib/python3.12/dist-packages (from torch) (3.1.6)\n", "Requirement already satisfied: fsspec in /usr/local/lib/python3.12/dist-packages (from torch) (2025.3.0)\n", "Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.6.77 in /usr/local/lib/python3.12/dist-packages (from torch) (12.6.77)\n", "Requirement already satisfied: nvidia-cuda-runtime-cu12==12.6.77 in /usr/local/lib/python3.12/dist-packages (from torch) (12.6.77)\n", "Requirement already satisfied: nvidia-cuda-cupti-cu12==12.6.80 in /usr/local/lib/python3.12/dist-packages (from torch) (12.6.80)\n", "Requirement already satisfied: nvidia-cudnn-cu12==9.10.2.21 in /usr/local/lib/python3.12/dist-packages (from torch) (9.10.2.21)\n", "Requirement already satisfied: nvidia-cublas-cu12==12.6.4.1 in /usr/local/lib/python3.12/dist-packages (from torch) (12.6.4.1)\n", "Requirement already satisfied: nvidia-cufft-cu12==11.3.0.4 in /usr/local/lib/python3.12/dist-packages (from torch) (11.3.0.4)\n", "Requirement already satisfied: nvidia-curand-cu12==10.3.7.77 in /usr/local/lib/python3.12/dist-packages (from torch) (10.3.7.77)\n", "Requirement already satisfied: nvidia-cusolver-cu12==11.7.1.2 in /usr/local/lib/python3.12/dist-packages (from torch) (11.7.1.2)\n", "Requirement already satisfied: nvidia-cusparse-cu12==12.5.4.2 in /usr/local/lib/python3.12/dist-packages (from torch) (12.5.4.2)\n", "Requirement already satisfied: nvidia-cusparselt-cu12==0.7.1 in /usr/local/lib/python3.12/dist-packages (from torch) (0.7.1)\n", "Requirement already satisfied: nvidia-nccl-cu12==2.27.3 in /usr/local/lib/python3.12/dist-packages (from torch) (2.27.3)\n", "Requirement already satisfied: nvidia-nvtx-cu12==12.6.77 in /usr/local/lib/python3.12/dist-packages (from torch) (12.6.77)\n", "Requirement already satisfied: nvidia-nvjitlink-cu12==12.6.85 in /usr/local/lib/python3.12/dist-packages (from torch) (12.6.85)\n", "Requirement already satisfied: nvidia-cufile-cu12==1.11.1.6 in /usr/local/lib/python3.12/dist-packages (from torch) (1.11.1.6)\n", "Requirement already satisfied: triton==3.4.0 in /usr/local/lib/python3.12/dist-packages (from torch) (3.4.0)\n", "Requirement already satisfied: numpy in /usr/local/lib/python3.12/dist-packages (from torchvision) (2.0.2)\n", "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /usr/local/lib/python3.12/dist-packages (from torchvision) (11.3.0)\n", "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.12/dist-packages (from sympy>=1.13.3->torch) (1.3.0)\n", "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.12/dist-packages (from jinja2->torch) (3.0.2)\n" ] } ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 1000 }, "id": "3445a762", "outputId": "29f914e1-65ba-44b6-aeda-778c3e1eb269" }, "source": [ "import numpy as np\n", "import torch\n", "\n", "# Generate synthetic data\n", "np.random.seed(42)\n", "num_samples = 1000\n", "\n", "# Features: Age, Income, Investments\n", "age = np.random.randint(18, 70, size=num_samples)\n", "income = np.random.normal(50000, 15000, size=num_samples) # Average income\n", "investments = np.random.normal(10000, 5000, size=num_samples) # Average investments\n", "\n", "# Wealth target: a simple function of the features (you can modify this)\n", "wealth = 0.4 * age + 0.5 * (income / 1000) + 0.3 * (investments / 1000) + np.random.normal(0, 5, size=num_samples)\n", "\n", "# Convert to PyTorch tensors\n", "X = torch.tensor(np.column_stack((age, income, investments)), dtype=torch.float32)\n", "y = torch.tensor(wealth, dtype=torch.float32).view(-1, 1)\n", "\n", "import torch.nn as nn\n", "import torch.optim as optim\n", "\n", "class WealthModel(nn.Module):\n", " def __init__(self):\n", " super(WealthModel, self).__init__()\n", " self.fc1 = nn.Linear(3, 64) # 3 input features\n", " self.fc2 = nn.Linear(64, 32)\n", " self.fc3 = nn.Linear(32, 1) # Output is a single value (wealth)\n", "\n", " def forward(self, x):\n", " x = torch.relu(self.fc1(x))\n", " x = torch.relu(self.fc2(x))\n", " x = self.fc3(x) # No activation function on output layer for regression\n", " return x\n", "\n", "model = WealthModel()\n", "\n", "# Training settings\n", "criterion = nn.MSELoss()\n", "optimizer = optim.Adam(model.parameters(), lr=0.001)\n", "num_epochs = 100\n", "\n", "# Training loop\n", "for epoch in range(num_epochs):\n", " model.train()\n", "\n", " # Forward pass\n", " outputs = model(X)\n", " loss = criterion(outputs, y)\n", "\n", " # Backward pass and optimization\n", " optimizer.zero_grad()\n", " loss.backward()\n", " optimizer.step()\n", "\n", " if (epoch+1) % 10 == 0:\n", " print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')\n", "\n", "model.eval()\n", "with torch.no_grad():\n", " predicted = model(X)\n", "\n", "# Optionally, you can visualize or calculate performance metrics\n", "import matplotlib.pyplot as plt\n", "\n", "plt.scatter(y.numpy(), predicted.numpy(), alpha=0.5)\n", "plt.xlabel('True Wealth')\n", "plt.ylabel('Predicted Wealth')\n", "plt.title('True vs Predicted Wealth')\n", "plt.plot([y.min(), y.max()], [y.min(), y.max()], '--', color='red')\n", "plt.show()\n", "\n", "class ObfuscationLayer(nn.Module):\n", " def __init__(self):\n", " super(ObfuscationLayer, self).__init__()\n", "\n", " def forward(self, x):\n", " # Add noise to simulate obfuscation/encryption\n", " noise = torch.normal(0, 0.1, x.size()).to(x.device) # Adjust the standard deviation for noise level\n", " return x + noise\n", "\n", "class EnhancedWealthModel(nn.Module):\n", " def __init__(self):\n", " super(EnhancedWealthModel, self).__init__()\n", " self.obfuscation = ObfuscationLayer()\n", " self.fc1 = nn.Linear(3, 128) # More units for complexity\n", " self.fc2 = nn.Linear(128, 64)\n", " self.fc3 = nn.Linear(64, 32)\n", " self.fc4 = nn.Linear(32, 1) # Output is a single value (wealth)\n", "\n", " def forward(self, x):\n", " x = self.obfuscation(x) # Apply obfuscation\n", " x = torch.relu(self.fc1(x))\n", " x = torch.relu(self.fc2(x))\n", " x = torch.relu(self.fc3(x))\n", " x = self.fc4(x) # No activation function on output layer for regression\n", " return x\n", "\n", "model = EnhancedWealthModel()\n", "\n", "# Training settings\n", "criterion = nn.MSELoss()\n", "optimizer = optim.Adam(model.parameters(), lr=0.001)\n", "num_epochs = 100\n", "\n", "# Training loop\n", "for epoch in range(num_epochs):\n", " model.train()\n", "\n", " # Forward pass\n", " outputs = model(X)\n", " loss = criterion(outputs, y)\n", "\n", " # Backward pass and optimization\n", " optimizer.zero_grad()\n", " loss.backward()\n", " optimizer.step()\n", "\n", " if (epoch + 1) % 10 == 0:\n", " print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item():.4f}')\n", "\n", "model.eval()\n", "with torch.no_grad():\n", " predicted = model(X)\n", "\n", "# Visualizing True vs. Predicted Wealth\n", "plt.scatter(y.numpy(), predicted.numpy(), alpha=0.5)\n", "plt.xlabel('True Wealth')\n", "plt.ylabel('Predicted Wealth')\n", "plt.title('True vs Predicted Wealth with Obfuscation Layer')\n", "plt.plot([y.min(), y.max()], [y.min(), y.max()], '--', color='red')\n", "plt.show()\n", "\n", "import torch\n", "import torch.nn as nn\n", "import torch.optim as optim\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", "# Define grid size\n", "grid_size = 20\n", "\n", "# Generate a sine waveform to represent wealth data\n", "def generate_wealth_waveform(grid_size):\n", " x = np.linspace(0, 2 * np.pi, grid_size)\n", " wealth_waveform = np.sin(x)\n", " return wealth_waveform\n", "\n", "# Create wealth data for the grid\n", "wealth_waveform = generate_wealth_waveform(grid_size)\n", "wealth_data = np.tile(wealth_waveform, (grid_size, 1)) # Repeat waveform along one axis\n", "\n", "# Convert wealth data to PyTorch tensor\n", "wealth_data = torch.tensor(wealth_data, dtype=torch.float32)\n", "\n", "# Define a simple neural network to \"transfer\" wealth data to a targeted account\n", "class WealthTransferNet(nn.Module):\n", " def __init__(self):\n", " super(WealthTransferNet, self).__init__()\n", " self.fc1 = nn.Linear(grid_size * grid_size, 128)\n", " self.fc2 = nn.Linear(128, grid_size * grid_size)\n", "\n", " def forward(self, x):\n", " x = torch.relu(self.fc1(x))\n", " x = self.fc2(x)\n", " return x\n", "\n", "# Instantiate the network, loss function, and optimizer\n", "net = WealthTransferNet()\n", "criterion = nn.MSELoss()\n", "optimizer = optim.Adam(net.parameters(), lr=0.01)\n", "\n", "# Target account: Wealth directed to bottom-right corner of the grid\n", "target_account = torch.zeros((grid_size, grid_size))\n", "target_account[-5:, -5:] = 1 # Simulating the transfer to a targeted account\n", "\n", "# Convert the grid to a single vector for the neural network\n", "input_data = wealth_data.view(-1)\n", "target_data = target_account.view(-1)\n", "\n", "# Training the network\n", "epochs = 500\n", "for epoch in range(epochs):\n", " optimizer.zero_grad()\n", " output = net(input_data)\n", " loss = criterion(output, target_data)\n", " loss.backward()\n", " optimizer.step()\n", "\n", "# Reshape the output to the grid size\n", "output_grid = output.detach().view(grid_size, grid_size)\n", "\n", "# Plot the original wealth waveform and transferred wealth\n", "fig, axes = plt.subplots(1, 3, figsize=(18, 6))\n", "axes[0].imshow(wealth_data, cmap='viridis')\n", "axes[0].set_title('Original Wealth Waveform')\n", "axes[1].imshow(target_account, cmap='viridis')\n", "axes[1].set_title('Target Account Location')\n", "axes[2].imshow(output_grid, cmap='viridis')\n", "axes[2].set_title('Transferred Wealth to Target')\n", "plt.show()\n", "\n", "import torch\n", "import torch.nn as nn\n", "import torch.optim as optim\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", "# Define the size of the waveform\n", "waveform_size = 100\n", "\n", "# Generate a sine waveform to represent wealth data\n", "def generate_wealth_waveform(waveform_size):\n", " x = np.linspace(0, 2 * np.pi, waveform_size)\n", " wealth_waveform = np.sin(x)\n", " return wealth_waveform\n", "\n", "# Create wealth data as a single waveform\n", "wealth_waveform = generate_wealth_waveform(waveform_size)\n", "wealth_data = torch.tensor(wealth_waveform, dtype=torch.float32)\n", "\n", "# Define a neural network to transfer wealth data to a targeted point in the waveform\n", "class WealthTransferNet(nn.Module):\n", " def __init__(self):\n", " super(WealthTransferNet, self).__init__()\n", " self.fc1 = nn.Linear(waveform_size, 64)\n", " self.fc2 = nn.Linear(64, waveform_size)\n", "\n", " def forward(self, x):\n", " x = torch.relu(self.fc1(x))\n", " x = self.fc2(x)\n", " return x\n", "\n", "# Instantiate the network, loss function, and optimizer\n", "net = WealthTransferNet()\n", "criterion = nn.MSELoss()\n", "optimizer = optim.Adam(net.parameters(), lr=0.01)\n", "\n", "# Target account: Wealth directed to the end of the waveform (right side)\n", "target_account = torch.zeros(waveform_size)\n", "target_account[-10:] = 1 # Simulating the transfer to the last 10 positions\n", "\n", "# Training the network\n", "epochs = 1000\n", "for epoch in range(epochs):\n", " optimizer.zero_grad()\n", " output = net(wealth_data)\n", " loss = criterion(output, target_account)\n", " loss.backward()\n", " optimizer.step()\n", "\n", "# Convert output to numpy for plotting\n", "output_waveform = output.detach().numpy()\n", "\n", "# Plot the original and transferred wealth waveform\n", "fig, ax = plt.subplots(figsize=(10, 5))\n", "ax.plot(wealth_data.numpy(), label=\"\", linestyle=\"--\")\n", "ax.plot(target_account.numpy(), label=\"\", linestyle=\":\")\n", "ax.plot(output_waveform, label=\"\")\n", "ax.set_title('')\n", "ax.legend()\n", "plt.show()" ], "execution_count": 3, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Epoch [10/100], Loss: 1777239.1250\n", "Epoch [20/100], Loss: 83456.6797\n", "Epoch [30/100], Loss: 389905.8125\n", "Epoch [40/100], Loss: 86084.4688\n", "Epoch [50/100], Loss: 16683.1934\n", "Epoch [60/100], Loss: 24780.8984\n", "Epoch [70/100], Loss: 13767.9600\n", "Epoch [80/100], Loss: 6193.5908\n", "Epoch [90/100], Loss: 3395.9180\n", "Epoch [100/100], Loss: 1606.8024\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "Epoch [10/100], Loss: 33273.3867\n", "Epoch [20/100], Loss: 28494.3809\n", "Epoch [30/100], Loss: 618.0955\n", "Epoch [40/100], Loss: 2332.7080\n", "Epoch [50/100], Loss: 1442.4009\n", "Epoch [60/100], Loss: 321.8962\n", "Epoch [70/100], Loss: 129.2351\n", "Epoch [80/100], Loss: 112.1005\n", "Epoch [90/100], Loss: 106.4330\n", "Epoch [100/100], Loss: 102.6665\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} }, { "output_type": "stream", "name": "stderr", "text": [ "/tmp/ipython-input-3070964569.py:261: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", " ax.legend()\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} } ] } ] }