问题描述：我正在开发一个用 Python 构建并使用 MySQL 数据库的监考考试系统。该系统包括一项在考试期间监控学生的功能（包括客观和

问题描述：

我正在开发一个用 Python 构建并使用 MySQL 数据库的监考考试系统。该系统包括一项功能，用于使用 TensorFlow 进行面部特征检测，在考试期间（客观和主观）监控学生。最近，在升级库并尝试匹配新趋势和标准后，我遇到了一个问题，即监控屏幕无法正确显示。我已经成功运行了该项目，并且一些功能正常运行。

错误信息：

`*WARNING:tensorflow:From E:\ExamAi\myenv\Lib\site-packages\tf_keras\src\losses.py:2976: The name tf.losses.sparse_softmax_cross_entropy is deprecated. Please use tf.compat.v1.losses.sparse_softmax_cross_entropy instead.

2024-07-16 19:38:07.825537: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.
To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.
Error loading the landmark model from models/pose_model.keras: Error when deserializing class 'InputLayer' using config={'batch_shape': [None, 4], 'dtype': 'float32', 'sparse': False, 'name': 'input_layer'}.

Exception encountered: Unrecognized keyword arguments: ['batch_shape']`

face_landmark.py：

import cv2
import numpy as np
import tensorflow as tf
from tensorflow import keras

def get_landmark_model(saved_model="models/pose_model.keras"):
    try:
        model = tf.keras.models.load_model(saved_model)
        return model
    except Exception as e:
        print(f"Error loading the landmark model from {saved_model}: {e}")
        return None

def get_square_box(box):
    left_x = box[0]
    top_y = box[1]
    right_x = box[2]
    bottom_y = box[3]

    box_width = right_x - left_x
    box_height = bottom_y - top_y

    diff = box_height - box_width
    delta = int(abs(diff) / 2)

    if diff == 0:                   # Already a square.
        return box
    elif diff > 0:                  # Height > width, a slim box.
        left_x -= delta
        right_x += delta
        if diff % 2 == 1:
            right_x += 1
    else:                           # Width > height, a short box.
        top_y -= delta
        bottom_y += delta
        if diff % 2 == 1:
            bottom_y += 1

    assert ((right_x - left_x) == (bottom_y - top_y)), 'Box is not square.'

    return [left_x, top_y, right_x, bottom_y]

def move_box(box, offset):
    left_x = box[0] + offset[0]
    top_y = box[1] + offset[1]
    right_x = box[2] + offset[0]
    bottom_y = box[3] + offset[1]
    return [left_x, top_y, right_x, bottom_y]

def detect_marks(img, model, face):
    offset_y = int(abs((face[3] - face[1]) * 0.1))
    box_moved = move_box(face, [0, offset_y])
    facebox = get_square_box(box_moved)
    
    h, w = img.shape[:2]
    if facebox[0] < 0:
        facebox[0] = 0
    if facebox[1] < 0:
        facebox[1] = 0
    if facebox[2] > w:
        facebox[2] = w
    if facebox[3] > h:
        facebox[3] = h
    
    face_img = img[facebox[1]: facebox[3], facebox[0]: facebox[2]]
    face_img = cv2.resize(face_img, (320, 320))
    face_img = cv2.cvtColor(face_img, cv2.COLOR_BGR2RGB)
    
    predictions = model.signatures["predict"](tf.constant([face_img], dtype=tf.uint8))
    marks = np.array(predictions['output']).flatten()[:136]
    marks = np.reshape(marks, (-1, 2))
    marks *= (facebox[2] - facebox[0])
    marks[:, 0] += facebox[0]
    marks[:, 1] += facebox[1]
    marks = marks.astype(np.uint)

    return marks

保存的模型.py：

import os
import tensorflow as tf
import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

def build_model(input_shape):
    model = tf.keras.Sequential([
        tf.keras.layers.Input(shape=input_shape, name='input_layer'),
        tf.keras.layers.Dense(10, activation='relu'),
        tf.keras.layers.Dense(3, activation='softmax')  # 3 classes for Iris dataset
    ])
    model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
    return model

def main():
    # Load Iris dataset
    iris = load_iris()
    X = iris.data
    y = iris.target

    # Split data into training and validation sets
    x_train, x_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42)

    # Standardize the data (mean=0, variance=1)
    scaler = StandardScaler()
    x_train = scaler.fit_transform(x_train)
    x_val = scaler.transform(x_val)

    # Build the model
    input_shape = (x_train.shape[1],)  # Number of features
    model = build_model(input_shape)

    # Train the model
    model.fit(x_train, y_train, epochs=10, batch_size=32, validation_data=(x_val, y_val))

    # Save the model in the Keras format
    model_file = 'models/pose_model.keras'
    if not os.path.exists('models'):
        os.makedirs('models')
    if os.path.exists(model_file):
        os.remove(model_file)
    tf.keras.models.save_model(model, model_file, save_format='keras')
    print("Model saved successfully.")

    # Load the model back to check if saved correctly
    loaded_model = tf.keras.models.load_model(model_file, custom_objects={'InputLayer': tf.keras.layers.InputLayer})
    print("Model loaded successfully.")

    # Optionally, test the loaded model
    predictions = loaded_model.predict(x_val[:5])
    print("Predictions:", predictions)

if __name__ == "__main__":
    main()

补充笔记：

我尝试通过 save_model.py 创建一个新的 pose_model.keras，但问题仍然存在。寻求帮助以尽快解决此问题，因为它对于演示至关重要。要求：

我将非常感激任何有关解决此问题的帮助或指导，尤其是与 TensorFlow 模型加载和 InputLayer 配置相关的帮助或指导。我也可以参加任何在线会议。

运行此代码时我只看到一辆车这是主要代码：Car leafy;Car honda;void setup(){ size(1920, 1080); leafy=new Car(0,900); honda=new Car(400, 500);}void draw(){...

当我运行此代码时，我只看到一辆车这是主要代码：

Car leafy;
Car honda;

void setup(){
    size(1920, 1080);
    leafy=new Car(0,900);
    honda=new Car(400, 500);
}

void draw(){
    background(#736FEA);
    leafy.display();

    honda.display();
    leafy.movement();
    honda.movement();
}

这是 Car 对象代码：

int xloc;
int yloc;

boolean windshieldControl;

class Car {
    Car(int x, int y){
        windshieldControl=true;
        xloc=x;
        yloc=y;
    }

    void display() {
        fill(#FFA600);
        rect(xloc, yloc, 150, 100);
        fill(#0B0B0D);
        circle(xloc+35, yloc+100, 30);
        circle(xloc+125, yloc+100, 30);
        fill(#7AF7F0);
        windshield();
    }

    void movement() {
        if (keyPressed) {
    
            if (key=='d' || key=='D') {
                windshieldControl=true;
                xloc=xloc+5;
            }

            if (key=='a' || key=='A') {
                xloc=xloc-5;
                windshieldControl=false;
            }
        }
    }

    void windshield() {
        if (windshieldControl) {
            arc(xloc+150, yloc+30, 100, 50, PI/2, 3*PI/2);
        }
        else {
            arc(xloc, yloc+30, 100, 50, 3*PI/2, 5*PI/2);
        }
    }
}

当我运行它时，我只看到一辆车被绘制出来 - 只有第二辆车出现。有人知道发生了什么吗？谢谢你的帮助。

我本以为会看到两辆不同的汽车出现在不同的位置，但我只看到了一辆车。不知道为什么……，

您已成功创建了两个 Car 实例。您只能看到一辆汽车，因为它们共享相同的 x 和 y 坐标，因此会重叠绘制。创建汽车时，您目前只是重新分配全局 xloc 和 yloc 变量。

因此，当你创建第一辆汽车时，你分配 xloc 和 yloc 值 0, 900 - 当你创建第二辆汽车时，你将相同的值重新分配给 400, 500

您的 int xloc 和 int yloc 是在类之外定义的，因此它们并不像您期望的那样真正属于该类。

如果您查看 class 文档，您会发现您想要 this.<varname> 在内部 constructor 来定义属于该类的特定实例的属性。

class Frog { 

   constructor(x, y, size) 
   { 
      // This code runs once when an instance is created. 
      this.x = x; 
      this.y = y; 
      this.size = size; 
   }
}

这样，frag 的每个实例都有单独的 x 和 y 值，现在您只是在两个类实例中使用类之外的变量。

我目前正在尝试使用 Google Collab 中的 Llama-3 LLM 进行交叉验证，但我面临的问题是，在完成实验之前，GPU 内存就已经耗尽。我的代码是...

我目前正在尝试使用 Google Collab 中的 Llama-3 LLM 进行交叉验证，并且我面临的问题是 GPU 内存在我能够完成实验之前就耗尽了。我的代码如下：

我有这个功能来清除内存：

from GPUtil import showUtilization as gpu_usage
from numba import cuda
import gc
from accelerate import Accelerator

accelerator = Accelerator()

def free_gpu_cache():
  print('Initial GPU Usage')
  gpu_usage()

  gc.collect()
  torch.cuda.empty_cache()
  accelerator.free_memory()

  cuda.select_device(0)
  cuda.close()
  cuda.select_device(0)

  print("GPU Usage after emptying the cache")
  gpu_usage()

这是我正在使用的主要代码：

for train_index, test_index in kf.split(data):
    training_data, test_data = data['text'][train_index], data['text'][test_index]

    training_data = Dataset.from_pandas(training_data.to_frame().reset_index())
    test_data = Dataset.from_pandas(test_data.to_frame().reset_index())

    
    free_gpu_cache()

    # model
    model = AutoModelForCausalLM.from_pretrained(model_name,
                                                device_map='auto',
                                                quantization_config=bnb_config,
                                                token = access_token)

    model.config.use_cache = False
    model.config.pretraining_tp = 1

    trainer = SFTTrainer(
      model = model,
      train_dataset = training_data,
      peft_config = lora_config,
      dataset_text_field = 'text',
      max_seq_length = 30,
      tokenizer = tokenizer,
      args = training_arguments,
      packing = True
    )

    trainer.train()

即使我有清除内存的功能，但在第二次迭代中仍然出现以下错误：

ValueError：部分模块在 CPU 或磁盘上调度。请确保您有足够的 GPU RAM 来适应量化模型。

我尝试使用上面显示的功能清除内存，但是没有效果。

我也尝试过这个：

import gc
gc.collect()
torch.cuda.empty_cache()

但它也不起作用。

我不知道还能做什么

我不确定这是否正确，所以你可能需要等待其他人来回答。但我相信“刷新 google colabs”内存不会起作用，因为 colab 的赚钱方式有：1. 限制内存访问，2. 付费访问更好的 GPU。

我正在访问 HousePrices.csv 数据集。分配数据框后，我尝试优化内存，为此我正在更改数据类型。令我惊讶的是，我能够更改日期对象...

我正在访问 HousePrices.csv 数据集。分配数据框后，我尝试优化内存，为此我正在更改数据类型。

令我惊讶的是，我能够将日期对象更改为日期时间。但是，即使我使用正确的命令，其他特征（如城市、国家、街道、州邮编数据类型）也不会改变。

你能帮忙吗？我们如何将上述数据类型更改为“字符串”类型？

[我正在向您发送我的笔记本 ipykernel Python3 的屏幕截图。]

更改数据类型失败！！！！

我希望能够更改数据类型，以确保当我使用 groupby 函数时不会出错。我假设由于这些特征是对象数据类型，因此它不允许我执行 groupby aggfunction(mean)。

问候

感谢您的阅读并尽力提供帮助:)

pandas 中没有专门的字符串数据类型。任何不是数字、日期时间或其他特定类型的数据都只是

我对数据框特征进行分组： df.groupby(['city']).mean()

欢迎来到 SO！我们理解您问题的前半部分。字符串单元格 dtype 将是对象，因此这里没有问题。然后，如果您需要有关 groupby 后续问题的帮助，前提是这还不存在问答（应该存在），请以文本形式发布输入示例和代码。文本对于

正如之前的评论所说，字符串在 Pandas 中没有特殊的数据类型，包含字符串的列属于“对象”类型。按字符串列对数据框进行分组应该不会有任何问题，但您将无法取平均值，因为这不是针对字符串的定义操作。

如果您想要按国家/地区分组，并在城市列中获取该国家/地区出现次数最多的城市，则可以使用 \'mode\'。但是，我怀疑您是想按多个列进行分组。如果您想获取每个国家/地区、城市、街道和州邮政编码组合的平均日期时间和价格，请尝试：

HousePrices.groupby['country','city','street','zipcode'].mean()