开放式创新的未来：趋势与预测

    import tensorflow as tf
    from sklearn.preprocessing import MinMaxScaler
    import numpy as np
    
    # 加载数据
    data = np.loadtxt('time_series.csv', delimiter=',')
    train_size = int(len(data) * 0.7)
    test_size = len(data) - train_size
    scaler = MinMaxScaler()
    scaled_data = scaler.fit_transform(data)
    
    def create_dataset(x, y, time_step=1):
    """
    创建数据集，其中 x 为输入，y 为输出，time_step 表示窗口大小
    """
    dataX, dataY = [], []
    for i in range(len(x) - time_step - 1):
        a = x[i:(i + time_step), 0]
        dataX.append(a)
        dataY.append(y[i + time_step])
    return np.array(dataX), np.array(dataY)
    
    # 创建训练集和测试集
    train_data = scaled_data[:train_size, :]
    test_data = scaled_data[train_size:, :]
    x_train, y_train = create_dataset(train_data[:, :-1], train_data[:, -1:])
    x_test, y_test = create_dataset(test_data[:, :-1], test_data[:, -1:], time_step=1)
    
    # 定义模型
    model = tf.keras.models.Sequential([
      tf.keras.layers.LSTM(units=128, input_shape=(None, 1)),
      tf.keras.layers.Dense(units=1)
    ])
    optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
    mse_loss = tf.keras.losses.MeanSquaredError()
    
    # 编译模型
    model.compile(optimizer=optimizer, loss='mean_squared_error', metrics=['mean_squared_error'])
    
    # 训练模型
    history = model.fit(x_train, y_train, epochs=100, batch_size=32, validation_split=0.2)
    
    # 预测模型
    predictions = model.predict(x_test)
    predicted_values = scaler.inverse_transform(np.concatenate((predictions, [[0]]), axis=-1))[-test_size:]
    
    # 评估模型
    test_values = scaler.inverse_transform([[v] for v in y_test])
    rmse = np.sqrt(((predicted_values - test_values)**2).mean())
    print("RMSE: %.2f" % rmse)

    import torch
    import torchvision
    import torchvision.transforms as transforms
    from torchsummary import summary
    
    
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    
    # 配置数据集
    transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]
    )
    
    batch_size = 4
    trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=False, transform=transform)
    trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,
                                          shuffle=True, num_workers=2)
    
    testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                      download=False, transform=transform)
    testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size,
                                         shuffle=False, num_workers=2)
    
    classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse','ship', 'truck')
    
    
    class Net(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = torch.nn.Conv2d(3, 6, kernel_size=5)
        self.pool = torch.nn.MaxPool2d(kernel_size=2, stride=2)
        self.conv2 = torch.nn.Conv2d(6, 16, kernel_size=5)
        self.fc1 = torch.nn.Linear(16 * 5 * 5, 120)
        self.fc2 = torch.nn.Linear(120, 84)
        self.fc3 = torch.nn.Linear(84, 10)
    
    def forward(self, x):
        x = self.pool(torch.nn.functional.relu(self.conv1(x)))
        x = self.pool(torch.nn.functional.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = torch.nn.functional.relu(self.fc1(x))
        x = torch.nn.functional.relu(self.fc2(x))
        x = self.fc3(x)
        return x
    
    
    net = Net().to(device)
    criterion = torch.nn.CrossEntropyLoss()
    optimizer = torch.optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
    
    for epoch in range(2):   # loop over the dataset multiple times
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data
        inputs, labels = inputs.to(device), labels.to(device)
    
        optimizer.zero_grad()
    
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
    
        # print statistics
        running_loss += loss.item()
        if i % 2000 == 1999:    # print every 2000 mini-batches
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 2000))
            running_loss = 0.0
    
    print('Finished Training')
    
    correct = 0
    total = 0
    with torch.no_grad():
    for data in testloader:
        images, labels = data
        images, labels = images.to(device), labels.to(device)
        outputs = net(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
    
    print('Accuracy of the network on the 10000 test images: %d %%' %
      (100 * correct / total))
    
    # 查看网络结构
    summary(net, input_size=(3, 32, 32))

    import mxnet as mx
    from mxnet import nd
    from mxnet.gluon import nn
    from mxnet.gluon.data.vision import datasets, transforms
    
    # 配置数据集
    mnist_train = datasets.FashionMNIST(train=True)
    transformer = transforms.Compose([transforms.ToTensor()])
    mnist_train = mnist_train.transform_first(transformer)
    train_data = mx.io.NDArrayIter(mnist_train['image'].expand_dims(axis=1),
                               mnist_train['label'], batch_size=100)
    
    mnist_val = datasets.FashionMNIST(train=False)
    mnist_val = mnist_val.transform_first(transformer)
    val_data = mx.io.NDArrayIter(mnist_val['image'].expand_dims(axis=1),
                             mnist_val['label'], batch_size=1000)
    
    # 配置模型
    ctx = mx.gpu() if mx.context.num_gpus() > 0 else mx.cpu()
    net = nn.Sequential()
    with net.name_scope():
    net.add(
        nn.Conv2D(channels=6, kernel_size=5, activation='relu'),
        nn.MaxPool2D(pool_size=2, strides=2),
        nn.Conv2D(channels=16, kernel_size=3, activation='relu'),
        nn.MaxPool2D(pool_size=2, strides=2),
        nn.Flatten(),
        nn.Dense(120, activation="relu"),
        nn.Dense(84, activation="relu"),
        nn.Dense(10)
    )
    
    net.collect_params().initialize(mx.init.Xavier(), ctx=ctx)
    
    softmax_cross_entropy = gluon.loss.SoftmaxCrossEntropyLoss()
    
    trainer = gluon.Trainer(net.collect_params(), 'adam', {'learning_rate': 0.01})
    
    metric = mx.metric.Accuracy()
    
    epochs = 5
    smoothing_constant =.01
    for e in range(epochs):
    cumulative_loss = 0
    metric.reset()
    
    for i, (data, label) in enumerate(train_data):
        data = data.as_in_context(ctx)
        label = label.as_in_context(ctx)
        
        with autograd.record():
            output = net(data)
            loss = softmax_cross_entropy(output, label)
            
        loss.backward()
        trainer.step(batch_size)
        
        predictions = nd.argmax(output, axis=1)
        metric.update(preds=[predictions], labels=[label])
        
    name, acc = metric.get()
    print("Epoch [%s] Validation Accuracy: %.2f%%" %(e+1,acc*100))