name: pytorchenv
channels:
    - defaults
    - pytorch
dependencies:
    - numpy=1.16.2
    - pandas=0.24.2
    - matplotlib=3.0.3
    - pillow=5.4.1
    - pip=19.0
    - plotly=3.7.0
    - scikit-learn=0.20.3
    - seaborn=0.9.0
    - python=3.11.7
    - jupyter=1.0.0
    - pytorch=1.1.0
    - torchvision=0.2.2
                    

import torch
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import torch.nn as nn
                    

x = torch.linspace(1,50,50).reshape(-1,1)
torch.manual_seed(71)
e = torch.randint(-8,9,(50,1),dtype=torch.float)
y = 2*x + 1 + e

plt.scatter(x.numpy(), y.numpy())
                    

import torch
import torch.nn as nn
import torch.nn.functional as F
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
                    

class Model(nn.Module):
def __init__(self, in_features=4, h1=8, h2=9, out_features=3):
    super().__init__()
    self.fc1=nn.Linear(in_features, h1)
    self.fc2=nn.Linear(h1, h2)
    self.out=nn.Linear(h2, out_features)

def forward(self, x):
    x=F.relu(self.fc1(x))
    x=F.relu(self.fc2(x))
    x=self.out(x)

    return x
                    

torch.manual_seed(32)
model=Model()

df = pd.read_csv('iris.csv')
fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(10,7))
fig.tight_layout()

plots = [(0,1),(2,3),(0,2),(1,3)]
colors = ['b', 'r', 'g']
labels = ['Iris setosa','Iris virginica','Iris versicolor']

for i, ax in enumerate(axes.flat):
    for j in range(3):
        x = df.columns[plots[i][0]]
        y = df.columns[plots[i][1]]
        ax.scatter(df[df['target']==j][x], df[df['target']==j][y], color=colors[j])
        ax.set(xlabel=x, ylabel=y)

fig.legend(labels=labels, loc=3, bbox_to_anchor=(1.0,0.85))
plt.show()
                    

X = df.drop('target', axis=1).values
y = df['target'].values

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=33)

X_train = torch.FloatTensor(X_train)
X_test = torch.FloatTensor(X_test)
y_train = torch.LongTensor(y_train)
y_test = torch.LongTensor(y_test)

criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
                    

epochs = 100
losses = []

for i in range(epochs):
y_pred = model.forward(X_train)
loss = criterion(y_pred, y_train)
losses.append(loss.item())

if i%10==0:
    print(f'epoch {i} and loss is {loss}')

optimizer.zero_grad()
loss.backward()
optimizer.step()

plt.plot(range(epochs), losses)
plt.ylabel('LOSS')
plt.xlabel('Epoch')
                    

correct = 0
with torch.no_grad():
    for i, data in enumerate(X_test):
        y_val = model.forward(data)
        print (f'{i+1}.)  {str(y_val)}  {y_test[i]}')
        if y_val.argmax().item() == y_test[i]:
            correct += 1

print (f'we got {correct} correct count')
                    

import torch
import torch.nn as nn
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt