请使用lamda：x判断x中是否含有4，如果有返回True,没有返回False

你可以使用 lambda 函数来判断一个数值 `x` 是否包含数字 4。下面是示例代码：

contains_4 = lambda x: True if '4' in str(x) else False

# 测试
print(contains_4(123))  # False
print(contains_4(456))  # True

在上述代码中，我们定义了一个名为 `contains_4` 的 lambda 函数。该函数接受一个数值 `x`，并使用 `str(x)` 将其转换为字符串。然后，我们使用 `'4' in str(x)` 来判断字符串中是否包含数字 4。如果包含，则返回 True，否则返回 False。

你可以传入不同的数值进行测试，看看是否包含数字 4，并根据返回结果判断是否包含。

相关问题

Math.random() 随机返回结果为20% 并返回true或者false，用java8中的Lamda表达式

在Java 8中，你可以使用`Math.random()`函数配合Lambda表达式来实现这个需求。`Math.random()`会生成一个0到1之间的随机浮点数，我们可以通过比较这个值与0.2来进行判断。如果随机数小于0.2，则返回`true`，否则返回`false`。以下是使用Lambda表达式的示例：

import java.util.function.BiFunction;
import java.util.Random;

public class Main {
    public static void main(String[] args) {
        // 创建一个BiFunction供后续操作
        BiFunction<Double, Double, Boolean> getRandomWithProbability = (randomNum, probability) -> randomNum < probability;

        // 使用Math.random()获取随机数，并应用Lambda表达式
        double randomNumber = Math.random();
        boolean result = getRandomWithProbability.apply(randomNumber, 0.2);
        
        System.out.println(result);  // 输出 true 或 false
    }
}

在这个例子中，`getRandomWithProbability`是一个接受两个double参数并返回boolean结果的函数，它通过Lambda表达式实现了所需的条件判断。

使用Python实现神经网络学习，输出使用后4000个样本训练得到模型在测试集上的结果并可视化，参数设置为： batch :300; iters _ num :2000; lamda :0.1

首先，我们需要准备数据集，将其分为训练集和测试集。假设我们有一个名为data的数据集，可以使用以下代码将其分为训练集和测试集（80%训练集，20%测试集）：

import numpy as np

data = np.load("data.npy")  # 加载数据集
np.random.shuffle(data)  # 打乱数据集

train_size = int(0.8 * len(data))  # 计算训练集大小
train_data = data[:train_size]  # 分割训练集
test_data = data[train_size:]  # 分割测试集

接下来，我们可以定义神经网络模型。假设我们有4个输入特征、2个隐藏层（每个层有10个神经元）和1个输出。可以使用以下代码定义模型：

import torch.nn as nn

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(4, 10)  # 第一层隐藏层
        self.fc2 = nn.Linear(10, 10)  # 第二层隐藏层
        self.fc3 = nn.Linear(10, 1)  # 输出层

    def forward(self, x):
        x = nn.functional.relu(self.fc1(x))  # 第一层隐藏层使用ReLU激活函数
        x = nn.functional.relu(self.fc2(x))  # 第二层隐藏层使用ReLU激活函数
        x = self.fc3(x)  # 输出层不使用激活函数
        return x

然后，我们可以定义训练函数，使用训练集训练模型：

import torch.optim as optim

def train(model, train_data, batch_size, iters_num, lamda):
    optimizer = optim.SGD(model.parameters(), lr=0.01)  # 优化器使用随机梯度下降
    criterion = nn.MSELoss()  # 损失函数使用均方误差
    losses = []
    for i in range(iters_num):
        batch_idx = np.random.choice(len(train_data), batch_size)  # 随机选择一个批次
        batch = train_data[batch_idx]
        x_train, y_train = batch[:, :4], batch[:, 4:]
        x_train, y_train = torch.FloatTensor(x_train), torch.FloatTensor(y_train)
        optimizer.zero_grad()  # 清空梯度
        outputs = model(x_train)  # 前向传播
        loss = criterion(outputs, y_train)  # 计算损失
        l2_reg = torch.tensor(0.)
        for name, param in model.named_parameters():
            if 'bias' not in name:
                l2_reg += torch.norm(param)
        loss += lamda * l2_reg
        loss.backward()  # 反向传播
        optimizer.step()  # 更新参数
        losses.append(loss.item())
    return losses

最后，我们可以使用测试集测试模型，并可视化结果：

import matplotlib.pyplot as plt

def test(model, test_data):
    x_test, y_test = test_data[:, :4], test_data[:, 4:]
    x_test, y_test = torch.FloatTensor(x_test), torch.FloatTensor(y_test)
    outputs = model(x_test)
    return outputs.detach().numpy()

model = Net()  # 创建模型
losses = train(model, train_data, batch_size=300, iters_num=2000, lamda=0.1)  # 训练模型
plt.plot(losses)  # 可视化损失函数
plt.show()

y_pred = test(model, test_data)  # 测试模型
plt.scatter(test_data[:, 4:], y_pred)  # 可视化测试结果
plt.xlabel("True Values")
plt.ylabel("Predictions")
plt.axis("equal")
plt.xlim(plt.xlim())
plt.ylim(plt.ylim())
plt.plot([-100, 100], [-100, 100])
plt.show()

这样，我们就实现了使用Python实现神经网络学习，并输出使用后4000个样本训练得到模型在测试集上的结果并可视化。