Допустим, есть вот такой json:
{"data":{"test":[
{
"date":"2020-07-07T00:00:00",
"time":"10-05",
"foo":"bar 1",
},
{
"date":"2020-07-07T00:00:00",
"time":"11-50",
"foo":"bar 1",
},
{
"date":"2020-07-08T00:00:00",
"time":"13-35",
"foo":"bar 2",
}
]}}

Нужно получить вот такой вывод (то есть сгруппировать по дате):
2020-07-07:
10-05: bar 1
11-50: bar 1

2020-07-08:
13-35: bar 2

Как это сделать?

>>46716
>>46686
Так понятнее?

class Node:
def __init__(self, values):
self.values = values

class value(Node):
def compute(self):
return self.values[0]

class add(Node):
def compute(self):
print (self.values[0])
return value(self.values[0].compute() + self.values[1].compute()).compute()

class sub(Node):
def compute(self):
return value(self.values[0].compute() - self.values[1].compute()).compute()

class mul(Node):
def compute(self):
return value(self.values[0].compute() self.values[1].compute()).compute()

class truediv(Node):
def compute(self):
return value(self.values[0].compute() / self.values[1].compute()).compute()

class mod(Node):
def compute(self):
return value(self.values[0].compute() % self.values[1].compute()).compute()

class pow(Node):
def compute(self):
return value(self.values[0].compute() self.values[1].compute()).compute()

a, b = value(5), value(2)
print(add(a, b).compute())

>>49884

import os
import pickle
import errno

import numpy as np

STORAGE_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), '.storage'))

class NeuralNetwork:
def __init__(self, input_nodes=3, hidden_nodes=3, output_nodes=3, rate=0.3, load_from=None):
"""
:param int input_nodes: количество узлов во входном слое
:param int hidden_nodes: количество узлов в скрытом слое
:param int output_nodes: количество узлов в выходном слое
:param float rate: коэфициент обучения
:param str load_from: загрузить данные из предварительно обученной модели
"""
if load_from is not None:
if not self.load(load_from):
raise ValueError('Model with name `{}` not found'.format(load_from))
else:
self.input_nodes = input_nodes
self.hidden_nodes = hidden_nodes
self.output_nodes = output_nodes
self.rate = rate
self.w_i_h = None # весовые коэффициенты между входным и скрытым слоем
self.w_h_o = None # весовые коэффициенты между скрытым и выходным слоем
self.__init_weights()

def train(self, input_list, target_list):
"""Тренировка нейронной сети - уточнение весовых коэффициентов
:param iterable input_list: входные данные
:param iterable target_list: целевые значения
"""
# Преобразуем входные данные в двумерный массив [1, 2, 3, 4] -> array([[1], [2], [3], [4]])
inputs = np.array(input_list, ndmin=2).T
targets = np.array(target_list, ndmin=2).T

# Расчитаем входящие сигналы для скрытого слоя
h_inputs = np.dot(self.w_i_h, inputs)

# Расчитаем исходящие сигналы для скрытого слоя
h_outputs = self.__activation_function(h_inputs)

# Расчитаем входящие сигналы для выходного слоя
o_inputs = np.dot(self.w_h_o, h_outputs)

# Расчитаем исходящие сигналы для выходного слоя
o_outputs = self.__activation_function(o_inputs)

# Выходная ошибка сети = целевое значение - фактическое значение
o_errors = targets - o_outputs

# Ошибки скрытого слоя - это ошибки выходного слоя сети,
# распределенные пропорционально весовым коэфициентам связей
# и рекомбинированные на скрытых узлах
h_errors = np.dot(self.w_h_o.T, o_errors)

# Обновим весовые по следующей формуле:
# alpha e sigmoid(x) (1 - sigmoid(x)) o, где
# alpha - коэфициент обучения,
# e - выходная ошибка,
# sigmoid(x) (1 - sigmoid(x)) - производная от функции активации (сигмойды в нашем случае),
# o - выходной сигнал предыдущего слоя.

# Обновим весовые коэфициенты между скрытым и выходным слоем сети
self.w_h_o += self.rate np.dot((o_errors o_outputs (1 - o_outputs)), h_outputs.T)

# Обновим весовые коэфициенты между входным и скрытым слоем сети
self.w_i_h += self.rate np.dot((h_errors h_outputs (1 - h_outputs)), inputs.T)

def predict(self, input_list):
"""Опрос нейронной сети - получение значений сигналов выходных узлов
:param iterable input_list: входные данные
:return numpy.array: выходные данные
"""
# Преобразуем входные данные в двумерный массив [1, 2, 3, 4] -> array([[1], [2], [3], [4]])
inputs = np.array(input_list, ndmin=2).T

# Расчитаем входящие сигналы для скрытого слоя
h_inputs = np.dot(self.w_i_h, inputs)

# Расчитаем исходящие сигналы для скрытого слоя
h_outputs = self.__activation_function(h_inputs)

# Расчитаем входящие сигналы для выходного слоя
o_inputs = np.dot(self.w_h_o, h_outputs)

# Расчитаем исходящие сигналы для выходного слоя
o_outputs = self.__activation_function(o_inputs)

return o_outputs

def back_query(self, output_list):
"""Осуществляет обратный запрос к сети
:param iterable output_list: обратные исходящие сигналы сети
:return numpy.array: выходные данные
"""
# Преобразуем входные данные в двумерный массив [1, 2, 3, 4] -> array([[1], [2], [3], [4]])
o_outputs = np.array(output_list, ndmin=2).T

# Преобразуем выходящие сигналы во входящие сигналы для выходного слоя
o_inputs = self.__back_activation_function(o_outputs)

# Расчитаем исходящие сигналы для скрытого слоя
h_outputs = np.dot(self.w_h_o.T, o_inputs)

# Нормализуем сигналы от 0.01 до 0.99, т.к. сигмойда не может давать знаения за пределами этих чисел
h_outputs -= np.min(h_outputs)
h_outputs /= np.max(h_outputs)
h_outputs = 0.98
h_outputs += 0.01

# Расчитаем входящие сигналы для скрытого слоя
hidden_inputs = self.__back_activation_function(h_outputs)

# Расчитаем исходящие сигналы для входного слоя
inputs = np.dot(self.w_i_h.T, hidden_inputs)

# Нормализуем сигналы от 0.01 до 0.99, т.к. сигмойда не может давать знаения за пределами этих чисел
inputs -= np.min(inputs)
inputs /= np.max(inputs)
inputs = 0.98
inputs += 0.01

return inputs

def save(self, key):
"""Сохраняет обученную модель
:param str key: имя модели
"""
try:
os.makedirs(STORAGE_PATH)
except OSError as e:
if e.errno != errno.EEXIST:
raise
file_path = os.path.join(STORAGE_PATH, key)
value = {
'input_nodes': self.input_nodes,
'hidden_nodes': self.hidden_nodes,
'output_nodes': self.output_nodes,
'rate': self.rate,
'w_i_h': self.w_i_h,
'w_h_o': self.w_h_o,
}
with open(file_path, mode='wb') as fn:
pickle.dump(value, fn, protocol=2)

def load(self, key):
"""Загружает обученную модель
:param str key: имя модели
"""
file_path = os.path.join(STORAGE_PATH, key)
if os.path.isfile(file_path):
with open(file_path, mode='rb') as fn:
value = pickle.load(fn)
self.input_nodes = value['input_nodes']
self.hidden_nodes = value['hidden_nodes']
self.output_nodes = value['output_nodes']
self.rate = value['rate']
self.w_i_h = value['w_i_h']
self.w_h_o = value['w_h_o']
return True
else:
return False

def __init_weights(self):
"""Инициализация случайных весов используя "улучшенный" вариант инициализации весовых коэфициентов.
Весовые коэфициенты выбираются из нормального распределения центром в нуле и со стандартным отклонением,
величина которого обратно пропорциональна квадратному корню из количества входящих связей на узел.
"""
self.w_i_h = np.random.normal(0.0, pow(self.hidden_nodes, -0.5), (self.hidden_nodes, self.input_nodes))
self.w_h_o = np.random.normal(0.0, pow(self.output_nodes, -0.5), (self.output_nodes, self.hidden_nodes))

@staticmethod
def __activation_function(x):
"""Функция активации нейронной сети
:param iterable x: матрица входящих сигналов сети
:return numpy.array: матрица сглаженных комбинированных сигналов
"""
return 1.0 / (1.0 + np.exp(-x)) # в качастве функции активации будет выступать сигмойда

@staticmethod
def __back_activation_function(y):
"""Функция обратной активации нейронной сети
В нашем случае, для сигмойды обратной функцией является логит - y = 1/(1 + e*-x) <=> x = ln(y/(1-y))
:param iterable y: матрица обратных исходящих сигналов сети
:return numpy.array: матрица обратно сглаженных комбинированных сигналов
"""
return np.log(y / (1.0 - y))

Посоны,нашел ESRGAN для видео, он контуженный. Я с питоном пока на вы, помогите исправить.
mport sys
import os.path
import glob
import cv2
import numpy as np
import torch
import architecture as arch

model_path = sys.argv[1] # models/RRDB_ESRGAN_x4.pth OR models/RRDB_PSNR_x4.pth
device = torch.device('cuda') # if you want to run on CPU, change 'cuda' -> cpu
# device = torch.device('cpu')

test_img_folder = 'LR_V/'

model = arch.RRDB_Net(3, 3, 64, 23, gc=32, upscale=4, norm_type=None, act_type='leakyrelu', \
mode='CNA', res_scale=1, upsample_mode='upconv')
model.load_state_dict(torch.load(model_path), strict=True)
model.eval()
for k, v in model.named_parameters():
v.requires_grad = False
model = model.to(device)

print('Model path {:s}. \nTesting...'.format(model_path))

idx = 0
for path in glob.glob(test_img_folder):
idx += 1
base = os.path.splitext(os.path.basename(path))[0]
print(idx, base)
cap = cv2.VideoCapture(path)
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) 4
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) 4
fps = int(cap.get(cv2.CAP_PROP_FPS))
out = cv2.VideoWriter('results/{:s}.avi'.format(base), cv2.VideoWriter_fourcc('M','J','P','G'), fps, (width,height))
while True:
ret, img = cap.read();
if img is None:
break
img = img 1.0 / 255
img = torch.from_numpy(np.transpose(img[:, :, [2, 1, 0]], (2, 0, 1))).float()
img_LR = img.unsqueeze(0)
img_LR = img_LR.to(device)

output = model(img_LR).data.squeeze().float().cpu().clamp_(0, 1).numpy()
output = np.transpose(output[[2, 1, 0], :, :], (1, 2, 0))
output = (output 255.0).round()
output = np.uint8(output)
out.write(output)
cap.release()
out.release()

Ошибка:

IPython 7.12.0 -- An enhanced Interactive Python.
Model path models/RRDB_ESRGAN_x4.pth.
Testing...
1 15946389272380
Traceback (most recent call last):

File "C:\Users\---\Desktop\ESRGAN-master\test.py", line 28, in <module>
img = img 1.0 / 255

TypeError: unsupported operand type(s) for *: 'NoneType' and 'float'