如何使用tensoflow来实现这个NN架构师? [英] How to implement this NN architect using tensoflow?
本文介绍了如何使用tensoflow来实现这个NN架构师?的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！
问题描述
我在这个领域是新手，也许这就是为什么我使事情变得混乱.我无法获得所需的结果，因为它显示的准确性非常低，这意味着我做错了.
I am new in this domain perhaps thats why i am confusing things. I am unable to get the required results as it shows very low accuracy which means i am doing it wrong.
import sklearn
import pandas as pd
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
import matplotlib.pyplot as plt
import sklearn.model_selection
from tensorflow.keras import layers
data= pd.read_csv("u.csv")
#print(data.head())
plt.plot(data)
plt.show()
import tensorflow
x=data.iloc[:,:3].values
y=data.iloc[:,-1].values
n_features = 1
n_steps = 3
x_train, x_test, y_train, y_test = sklearn.model_selection.train_test_split(x,y, test_size=0.1)
xtr=x_train
# create and fit the network
n_features = 1
x_train = x_train.reshape((x_train.shape[0], x_train.shape[1], n_features))
model = Sequential()
# expected input data shape: (batch_size, timesteps, data_dim)
model = tensorflow.keras.Sequential()
model.add(layers.Embedding(input_dim=3, output_dim=1)) # returns a sequence of vectors of dimension
model.add(layers.SimpleRNN(2, return_sequences=True)) # returns a sequence of vectors of dimension
model.add(layers.SimpleRNN(2)) # return a single vector of dimension 32
model.add(Dense(1, activation='softmax'))
model.compile(optimizer='adam', loss='mse')
model.fit(x_train, y_train)
x_test = x_test.reshape((x_test.shape[0], x_test.shape[1], n_features))
y_pred=model.predict(x_train)
#print(x_train.shape)
#print(y_train.shape)
print(model.layers[0].get_weights()[0]) # W - input weights
print(model.layers[0].get_weights()[1]) # U - recurrent weights
print(model.layers[0].get_weights()[2]) # b - output
m=model.layers[0].get_weights()[0]
推荐答案
如果要使用pytorch创建NN. NN的类型很多，三个组成部分是:
In case you want to the Create a NN using pytorch . There are many types of NN , the three building blocks are :
FFN:
- 前馈神经网络.
- CNN:卷积神经网络. Rli:递归神经网络. (LSTM是RNN的一种，您可以使用下面的RNN代码并对其进行更改以获取LSTM，如果您发现我将发布更改的困难，请告诉我)
- Feed forward neural Net.
- CNN : Convolution neural Net.
- RNN : Recurrent Neural net . (LSTM is a type of RNN , you can use the below RNN code and change it to get the LSTM , let me know if you find it difficult I will post the change)
让我们以FNN开头: FNN由三层组成:
Lets start with a FNN : A FNN consist of three layers :
- 输入层
- 隐藏层
- 读出层.
对于MNIST而言，每个输入层的形状都会发生变化，并且每个输入层都有自己的行为
In case of MNIST , Input layer shape changes for each and also each has its own behaviour
- FNN:扁平28 * 28
- CNN:频道，28,28:主要用于图像
- RNN:每步输入28和总共28个时间步. :对于时间序列数据类型[视频，文本，音频]
FNN的代码是:
import torch
import torch.nn as nn
from torch.autograd import Variable
import torchvision.datasets as dsets
import torchvision.transforms as transforms
train_dataset = dsets.MNIST(root="./data",
train=True,
transform=transforms.ToTensor(),
download=True
)
test_dataset = dsets.MNIST(root="./data",
train=False,
transform=transforms.ToTensor())
batch_size=100
n_iters = 3000
n_epochs = n_iters / (len(train_dataset)/batch_size)
n_epochs = int(n_epochs)
train_dataloader = torch.utils.data.DataLoader(dataset=train_dataset,
batch_size=batch_size,
shuffle=True)
test_dataloader = torch.utils.data.DataLoader(dataset=test_dataset,
batch_size=batch_size,
shuffle=False)
class FeedforwardNNModelSIG(nn.Module):
def __init__(self,input_dim,hidden_dim,output_dim):
super().__init__()
#Linear Layar
self.fc1=nn.Linear(input_dim,hidden_dim)
#Non Linear Layaer
self.sigmoid=nn.Sigmoid()
#Linear Layar(readout layer)
self.fc2=nn.Linear(hidden_dim,output_dim)
def forward(self,x):
# Linear
out = self.fc1(x)
# Non-Linear
out = self.sigmoid(out)
# Linear (readout layer)
out = self.fc2(out)
return out
input_dim=28*28
hidden_dim=50
output_dim=10
model = FeedforwardNNModelSIG(input_dim,hidden_dim,output_dim)
criterion = nn.CrossEntropyLoss()
learning_rate = 0.1
optimizer = torch.optim.SGD(model.parameters(),lr=learning_rate)
iter=0
for epoch in range(n_epochs):
for i,(images, labels) in enumerate(train_dataloader):
##1 Convert inputs/labels to Variable
images = Variable(images.view(-1,28*28))
labels = Variable(labels)
##2 Clear the gradients
optimizer.zero_grad()
##3 Get output given input
outputs = model(images)
##4 Get Loss
loss = criterion(outputs,labels)
##5 Get gradients wrt parameters
loss.backward()
##6 Update paramters using Gradients
optimizer.step()
##7 Repeat
iter +=1
if iter % 500 == 0 :
correct = 0.
total = 0.
# Iter thorough test dataset
for images,labels in test_dataloader:
images = Variable(images.view(-1,28*28))
labels = Variable(labels)
outputs = model(images)
# Get the max value of the prediction
_,predicted=torch.max(outputs.data,1)
# number of labels
total += labels.size(0)
# Total correct predictions
correct += (predicted==labels).sum()
accuracy = 100*(correct/total)
print("Iteration: {} , Loss:{} , Accuracy:{}".format(iter,loss.data,accuracy))
RNN的代码是:
import torch
import torch.nn as nn
from torch.autograd import Variable
import torchvision.datasets as dsets
import torchvision.transforms as transforms
train_dataset = dsets.MNIST(root="./data",
train=True,
transform=transforms.ToTensor(),
download=True
)
test_dataset = dsets.MNIST(root="./data",
train=False,
transform=transforms.ToTensor())
batch_size=100
n_iters = 3000
n_epochs = n_iters / (len(train_dataset)/batch_size)
n_epochs = int(n_epochs)
train_dataloader = torch.utils.data.DataLoader(dataset=train_dataset,
batch_size=batch_size,
shuffle=True)
test_dataloader = torch.utils.data.DataLoader(dataset=test_dataset,
batch_size=batch_size,
shuffle=False)
class RNNModel(nn.Module):
def __init__(self, input_dim, hidden_dim, layer_dim, output_dim):
super(RNNModel, self).__init__()
# Hidden dimensions
self.hidden_dim = hidden_dim
# Number of hidden layers
self.layer_dim = layer_dim
self.rnn = nn.RNN(input_dim, hidden_dim, layer_dim, batch_first=True, nonlinearity='tanh')
# Readout layer
self.fc = nn.Linear(hidden_dim, output_dim)
def forward(self, x):
# Initialize hidden state with zeros
#######################
# USE GPU FOR MODEL #
#######################
if torch.cuda.is_available():
h0 = Variable(torch.zeros(self.layer_dim, x.size(0), self.hidden_dim).cuda())
else:
h0 = Variable(torch.zeros(self.layer_dim, x.size(0), self.hidden_dim))
# One time step
out, hn = self.rnn(x, h0)
out = self.fc(out[:, -1, :])
# out.size() --> 100, 10
return out
input_dim = 28
hidden_dim = 100
layer_dim = 1 # ONLY CHANGE IS HERE FROM ONE LAYER TO TWO LAYER
output_dim = 10
model = RNNModel(input_dim, hidden_dim, layer_dim, output_dim)
criterion = nn.CrossEntropyLoss()
if torch.cuda.is_available():
model.cuda()
learning_rate = 0.1
optimizer = torch.optim.SGD(model.parameters(),lr=learning_rate)
seq_dim = 28
iter = 0
for epoch in range(num_epochs):
for i, (images, labels) in enumerate(train_loader):
# Load images as Variable
#######################
# USE GPU FOR MODEL #
#######################
if torch.cuda.is_available():
images = Variable(images.view(-1, seq_dim, input_dim).cuda())
labels = Variable(labels.cuda())
else:
images = Variable(images.view(-1, seq_dim, input_dim))
labels = Variable(labels)
# Clear gradients w.r.t. parameters
optimizer.zero_grad()
# Forward pass to get output/logits
# outputs.size() --> 100, 10
outputs = model(images)
# Calculate Loss: softmax --> cross entropy loss
loss = criterion(outputs, labels)
# Getting gradients w.r.t. parameters
loss.backward()
# Updating parameters
optimizer.step()
iter += 1
if iter % 500 == 0:
# Calculate Accuracy
correct = 0
total = 0
# Iterate through test dataset
for images, labels in test_loader:
#######################
# USE GPU FOR MODEL #
#######################
if torch.cuda.is_available():
images = Variable(images.view(-1, seq_dim, input_dim).cuda())
else:
images = Variable(images.view(-1, seq_dim, input_dim))
# Forward pass only to get logits/output
outputs = model(images)
# Get predictions from the maximum value
_, predicted = torch.max(outputs.data, 1)
# Total number of labels
total += labels.size(0)
# Total correct predictions
#######################
# USE GPU FOR MODEL #
#######################
if torch.cuda.is_available():
correct += (predicted.cpu() == labels.cpu()).sum()
else:
correct += (predicted == labels).sum()
accuracy = 100 * correct / total
# Print Loss
print('Iteration: {}. Loss: {}. Accuracy: {}'.format(iter, loss, accuracy))
这篇关于如何使用tensoflow来实现这个NN架构师?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
查看全文
