а путь-то верный? там идет проверка что по этому пути есть файл. и в ошибке написано что нет разрешений

Верный

Там сейчас время костылей идëт. Мне подсказку человек с линуксом даëт. У него этот код уже учится. У меня застрял в бесконечном цикле

Виндовс наказание какое-то

путь линуховый указан, тебе нужен путь для твоей машины, естественно не заработает так

ну и вообще этот путь выглядит как пример чисто)

наказание - отсутствие понимания базовых вещей и попытки запустить код, в логике которого не разобрались

Чел, даже с моим путëм не работает. Всë не на столько плохо

Но спорить не буду, чего-то я точно не понимаю

скинь путь

реальный

Так покажи что там у тебя

[os.path.join"D:\\keras-tutorial\\codes\\Ccodes\\"+f for f in os.listdir('D:\\keras-tutorial\\codes\\Ccodes')]+[os.path.join"D:\\keras-tutorial\\codes\\Bcodes\\"+f for f in os.listdir('D:\\keras-tutorial\\codes\\Bcodes')]

оставь только
D:\keras-tutorial\codes\Ccodes\

убери весь этот блок

у меня две папки должно вызываться

просто суть в чём, там были сложности с cv2, и после того как в цикле изображений было выставлено
if image is None:
continue
он стал уходить в бесконечный вызов

до большой строки выше были претензии к доступу на папки и файлы, хотя я все параметры безопасности выставлял

# USAGE
# python train_simple_nn.py --dataset animals --model output/simple_nn.model --label-bin output/simple_nn_lb.pickle --plot output/simple_nn_plot.png

# импортируем бэкенд Agg из matplotlib для сохранения графиков на диск
import matplotlib
matplotlib.use("Agg")

# подключаем необходимые пакеты
from mpl_toolkits.mplot3d import Axes3D
from sklearn.tree import DecisionTreeClassifier
from sklearn.preprocessing import LabelBinarizer
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from keras.models import Sequential
from keras.layers.core import Dense
from keras.optimizers import SGD
from imutils import paths
from tensorflow import keras
from tensorflow.keras.preprocessing import image
import matplotlib.pyplot as plt
import numpy as np
import argparse
import random
import pickle
import cv2
import os
import re
import os.path
import keras
import pandas as pd
from glob import glob

def obj():
   def obj_filter(obj):
       def populate_dict_with_module_objects(target_dict, modules, obj_filter):
           for module in modules:
               for name in dir(module):
                   obj = getattr(module, name)
                   if obj_filter(obj):
                       target_dict[name] = obj

# создаём парсер аргументов и передаём их
ap = argparse.ArgumentParser()
ap.add_argument("-d", "--dataset", required=True,
 help="path to input dataset of images")
ap.add_argument("-m", "--model", required=True,
 help="path to output trained model")
ap.add_argument("-l", "--label-bin", required=True,
 help="path to output label binarizer")
ap.add_argument("-p", "--plot", required=True,
 help="path to output accuracy/loss plot")
args = vars(ap.parse_args())

for k in args.keys():
   print(k)
print(args['dataset'])

# инициализируем данные и метки
try:
   # PIL
  import Image
except ImportError:
   # Pillow
   from PIL import Image

def process_image(img_path):
   #print(f"Processing image: {img_path}")
   # Open the image
   img = Image.open(img_path)

   # Do your processing here
   #print (img.info)

   # Not strictly necessary, but let's be explicit:
   # Close the image
   del img

images_dir = "D:\keras-tutorial\codes\Bcodes"
images_dir = "D:\keras-tutorial\codes\Ccodes"

if name == "main":
   # List all PNG files in your directory
   images_list = os.listdir(images_dir)
   #print(images_list)

   for img_filename in images_list:
       img_path = os.path.join(images_dir, img_filename)
       process_image(img_path)
       
print("[INFO] loading images...")
data = []
labels = []

# берём пути к изображениям и рандомно перемешиваем
imagePaths = [os.path.join("D:\\keras-tutorial\\codes\\Ccodes",f) for f in os.listdir('D:\\keras-tutorial\\codes\\Ccodes')]+[os.path.join("D:\\keras-tutorial\\codes\\Bcodes",f) for f in os.listdir('D:\\keras-tutorial\\codes\\Bcodes')]
random.seed(42)
random.shuffle(imagePaths)

# цикл по изображениям
for imagePath in imagePaths:
    for p in imagePaths:
        print(p)
 # загружаем изображение, меняем размер на 32x32 пикселей (без учета
 # соотношения сторон), сглаживаем его в 32x32x3=3072 пикселей и
 # добавляем в список
    image = cv2.imread(imagePath)
    if image is None:
        continue
print(image)
image = cv2.resize(image, (32, 32)).flatten()
data.append(image)

 # извлекаем метку класса из пути к изображению и обновляем
 # список меток
label = imagePath.split(os.path.sep)[-2]
labels.append(label)

# масштабируем интенсивности пикселей в диапазон [0, 1]
data = np.array(data, dtype="float") / 255.0
labels = np.array(labels)
print(data.shape)

# разбиваем данные на обучающую и тестовую выборки, используя 75%
# данных для обучения и оставшиеся 25% для тестирования
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split (data,
                                                    labels,
                                                    test_size=0.25,
                                                    train_size=0.75,
                                                    random_state=42)

# конвертируем метки из целых чисел в векторы (для 2х классов при
# бинарной классификации вам следует использовать функцию Keras
# “to_categorical” вместо “LabelBinarizer” из scikit-learn, которая
# не возвращает вектор)
lb = LabelBinarizer()
trainY = lb.fit_transform(trainY)
testY = lb.transform(testY)

# определим архитектуру 8-8-1 с помощью Keras
def create_model(lyrs=[8], act='linear', opt='Adam', dr=0.0):
   # set random seed for reproducibility
   seed(42)
   tf.random.set_seed(42)
   model = tf.keras.Sequential()
   # create first hidden layer
   model.add(tf.keras.Dense(lyrs[0], input_dim=X_train.shape[1], activation=act))
   # create additional hidden layers
   for i in range(1, len(lyrs)):
       model.add(tf.keras.Dense(lyrs[i], activation=act))
       # add dropout, default is none
   model.add(tf.keras.Dropout(dr))
   # create output layer
   model.add(tf.keras.Dense(1, activation='sigmoid'))  # output layer
   model.complete(loss='binary_crossentropy', optimizer=opt, metrics=['accuracy'])
   return model

# инициализируем скорость обучения и общее число эпох
   model = tf.keras.KerasClassifier(build_nf=create_model, verbose=0)

   # define the grid search parameters
   batch_size = [16, 32, 64]
   epochs = [50, 100]
   param_grid = dict(batch_size=batch_size, ephochs=epochs)

   # search the grid
   grid = tf.keras.GridSearchCV(estimator=model,
                                param_grid=param_grid,
                                cv=3,
                                verbose=2)  # include n_jobs=-1 if you are using CPU
   grid_result = grid.fit(X_train, y_train)

# обучаем нейросеть
H = model.fit(trainX, trainY, validation_data=(testX, testY),
 epochs=EPOCHS, batch_size=32)

# оцениваем нейросеть
print("[INFO] evaluating network...")
predictions = model.predict(testX, batch_size=32)
print(classification_report(testY.argmax(axis=1),
 predictions.argmax(axis=1), target_names=lb.classes_))

# строим графики потерь и точности
N = np.arange(0, EPOCHS)
plt.style.use("ggplot")
plt.figure()
plt.plot(N, H.history["loss"], label="train_loss")
plt.plot(N, H.history["val_loss"], label="val_loss")
plt.plot(N, H.history["acc"], label="train_acc")
plt.plot(N, H.history["val_acc"], label="val_acc")
plt.title("Training Loss and Accuracy (Simple NN)")
plt.xlabel("Epoch #")
plt.ylabel("Loss/Accuracy")
plt.legend()
plt.savefig(args["plot"])