Масса 24 швеллера: Швеллер 24 – цена за метр, вес, размер. Доставка по Москве

Калькулятор веса стального швеллера. Торговый Дом «Профиль»

Квадратная

Прямоугольная

Круглая

Уголок

Швеллер

Полоса

Лист

Арматура

Квадрат

Балка

Круг

В зависимости от способа производства швеллера используются различные формулы расчета веса погонного метра. Для того, чтобы рассчитать удельный вес горячекатаного швеллера необходимо знать радиусы внутреннего закругления и закругления полок. Также, при производстве горячекатаных швеллеров, в отличие от гнутых по ГОСТ 8278–83 и 8281–80, зачастую толщина полок отличается от толщины стенки швеллера, что также повлияет на формулу расчета веса.

В калькуляторе веса швеллера вы сможете осуществить поиск по наименованию и размерам на основе информации справочников различных стандартов, в случае если швеллер вашего размера не будет найден, его вес будет рассчитан по приблизительной формуле.

Таблицы теоретической массы метра швеллера и его размеров

ГОСТ 8240-97 — Швеллеры стальные горячекатаные

Теоретическая масса 1 погонного метра швеллера по ГОСТ 8240-97

Наименование	h	a	b	s	t	Вес 1 м, кг	Метров в тонне
Швеллер 5Э	50	32	32	4,2	7	4.790	208.77
Швеллер 5У	50	32	32	4,4	7	4.840	206.61
Швеллер 5П	50	32	32	4,4	7	4. 840	206.61
Швеллер 6.5Э	65	36	36	4,2	7,2	5.820	171.82
Швеллер 6.5У	65	36	36	4,4	7,2	5.900	169.49
Швеллер 6.5П	65	36	36	4,4	7,2	5.900	169.49
Швеллер 8Э	80	40	40	4,2	7,4	6.920	144.51
Швеллер 8У	80	40	40	4,5	7,4	7.050	141.84
Швеллер 8П	80	40	40	4,5	7,4	7.050	141.84
Швеллер 8С	80	45	45	5,5	9	9. 260	107.99
Швеллер 10Э	100	46	46	4,2	7,6	8.470	118.06
Швеллер 10У	100	46	46	4,5	7,6	8.590	116.41
Швеллер 10П	100	46	46	4,5	7,6	8.590	116.41
Швеллер 12Л	120	30	30	3	4,8	5.020	199.2
Швеллер 12Э	120	52	52	4,5	7,8	10.240	97.66
Швеллер 12У	120	52	52	4,8	7,8	10.400	96.15
Швеллер 12П	120	52	52	4,8	7,8	10. 400	96.15
Швеллер 14Л	140	32	32	3,2	5,6	5.940	168.35
Швеллер 14Э	140	58	58	4,6	8,1	12.150	82.3
Швеллер 14У	140	58	58	4,9	8,1	12.300	81.3
Швеллер 14П	140	58	58	4,9	8,1	12.300	81.3
Швеллер 14С	140	58	58	6	9,5	14.530	68.82
Швеллер 14Са	140	60	60	8	9,5	16.720	59.81
Швеллер 16Л	160	35	35	3,4	5,3	7. 100	140.85
Швеллер 16С	160	63	63	6,5	10	17.530	57.05
Швеллер 16Э	160	64	64	4,7	8,4	14.010	71.38
Швеллер 16У	160	64	64	5	8,4	14.200	70.42
Швеллер 16П	160	64	64	5	8,4	14.200	70.42
Швеллер 16Са	160	65	65	8,5	10	19.740	50.66
Швеллер 16аУ	160	68	68	5	9	15.300	65.36
Швеллер 16аП	160	68	68	5	9	15. 300	65.36
Швеллер 18Л	180	40	40	3,6	5,6	8.490	117.79
Швеллер 18С	180	68	68	7	10,5	20.200	49.5
Швеллер 18Э	180	70	70	4,8	8,7	16.010	62.46
Швеллер 18У	180	70	70	5,1	8,7	16.300	61.35
Швеллер 18П	180	70	70	5,1	8,7	16.300	61.35
Швеллер 18Са	180	70	70	9	10,5	23.000	43.48
Швеллер 18аУ	180	74	74	5,1	9,3	17. 400	57.47
Швеллер 18аП	180	74	74	5,1	9,3	17.400	57.47
Швеллер 18Сб	180	100	100	8	10,5	26.720	37.43
Швеллер 20Л	200	45	45	3,8	6	10.120	98.81
Швеллер 20С	200	73	73	7	11	22.630	44.19
Швеллер 20Са	200	75	75	9	11	25.770	38.8
Швеллер 20Э	200	76	76	4,9	9	18.070	55.34
Швеллер 20У	200	76	76	5,2	9	18. 400	54.35
Швеллер 20П	200	76	76	5,2	9	18.400	54.35
Швеллер 20Сб	200	100	100	8	11	28.710	34.83
Швеллер 22Л	220	50	50	4	6,4	11.860	84.32
Швеллер 22Э	220	82	82	5,1	9,5	20.690	48.33
Швеллер 22У	220	82	82	5,4	9,5	21.000	47.62
Швеллер 22П	220	82	82	5,4	9,5	21.000	47.62
Швеллер 24Л	240	55	55	4,2	6,8	13. 660	73.21
Швеллер 24С	240	85	85	9,5	14	34.900	28.65
Швеллер 24Э	240	90	90	5,3	10	23.690	42.21
Швеллер 24У	240	90	90	5,6	10	24.000	41.67
Швеллер 24П	240	90	90	5,6	10	24.000	41.67
Швеллер 26С	260	65	65	10	16	34.610	28.89
Швеллер 26Са	260	90	90	10	15	39.720	25.18
Швеллер 27Л	270	60	60	4,5	7,3	16. 300	61.35
Швеллер 27Э	270	95	95	5,8	10,5	27.370	36.54
Швеллер 27У	270	95	95	6	10,5	27.700	36.1
Швеллер 27П	270	95	95	6	10,5	27.700	36.1
Швеллер 30Л	300	65	65	4,8	7,8	19.070	52.44
Швеллер 30С	300	85	85	7,5	13,5	34.440	29.04
Швеллер 30Са	300	87	87	9,5	13,5	39.150	25.54
Швеллер 30Сб	300	89	89	11,5	13,5	43. 860	22.8
Швеллер 30Э	300	100	100	6,3	11	31.350	31.9
Швеллер 30У	300	100	100	6,5	11	31.800	31.45
Швеллер 30П	300	100	100	6,5	11	31.800	31.45
Швеллер 33Э	330	105	105	6,9	11,7	36.140	27.67
Швеллер 33У	330	105	105	7	11,7	36.500	27.4
Швеллер 33П	330	105	105	7	11,7	36.500	27.4
Швеллер 36Э	360	110	110	7,4	12,6	41. 530	24.08
Швеллер 36У	360	110	110	7,5	12,6	41.900	23.87
Швеллер 36П	360	110	110	7,5	12,6	41.900	23.87
Швеллер 40Э	400	115	115	7,9	13,5	47.970	20.85
Швеллер 40У	400	115	115	8	13,5	48.300	20.7
Швеллер 40П	400	115	115	8	13,5	48.300	20.7

Телефоны

8 800 100 17 62 (бесплатно по всей территории России)

+7 495 543 91 20 (многоканальный)

+7 985 739 17 20

Поделиться:

Корзина

0 элементов

Таблица весов арматуры, швеллера листа, двутавра, полосы

Масса металлопроката в таблице

Масса стержневой арматуры (ГОСТ 5781-82)
Ф стержня(мм)	6	8	10	12	14	16	18	20	22	25	28	32	36	40	45	50	55	60	70	80
Масса 1м пр. (кг)	0,222	0,395	0,617	0,888	1,210	1,580	2,000	2,470	2,980	3,850	4,830	6,310	7,990	9,870	12,480	15,410	18,650	22,190	30,210	39,460
Пл.поп.сеч.(см2)	0,283	0,503	0,785	1,131	1,540	2,010	2,540	3,140	3,800	4,910	6,160	8,040	10,180	12,570	15,000	19,630	23,760	28,270	38,480	50,270
Масса листа (из расчета удельного веса 7,85 г/см2)
Толщина (мм)	0,5	0,55	0,6	0,7	0,8	0,9	1,0	1,2	1,4	1,5	1,7	1,8	1,9	2,0	2,5	3,0	3,5	4,0
Масса кг/м2	3,925	4,32	4,71	5,50	6,28	7,06	7,85	9,42	10,99	11,77	13,34	14,13	14,91	15,70	19,62	23,55	27,47	31,40
Толщина (мм)	5,0	6,0	7,0	8,0	9,0	10	12	14	16	18	20	22	25	30	40	50	60
Масса кг/м2	39,25	47,10	54,95	62,80	70,65	78,50	94,20	109,9	125,6	141,3	157,0	172,7	196,25	235,5	314,0	392,5	471,0
Масса равнополочных уголков (ГОСТ 8509-93)
Размеры (мм)	20х4	25х4	32х4	35х4	36х4	40х4	40х5	45х4	45х5	50х4	50х5	63х4	63х5	63х6	70х7	75х5	75х6	75х7	80х7	80х8
Масса 1м, кг	1,15	1,46	1,91	2,12	2,16	2,42	2,97	2,73	3,37	3,05	3,77	3,90	4,81	5,72	7,39	5,80	6,89	7,96	8,51	9,65
Размеры (мм)	90х7	90х8	100х7	100х8	100х10	100х12	110х7	110х8	125х8	125х9	125х10	125х12	140х10	140х12	160х10	160х12	180х11	180х12	200х16	200х20
Масса 1м, кг	9,64	10,90	10,80	12,20	15,10	17,90	11,90	13,50	15,50	17,30	19,10	22,70	21,50	25,50	24,70	29,40	30,50	33,10	48,70	60,10
Масса швеллера (ГОСТ 8240-89)
Номер швеллера	5; 5П	6,5	8; 8П	10;10П	12;12П	14;14П	16;16П	16А	18;18П	18А	20;20П	22;22П	24;24П	27;27П	30;30П	33;33П	36;36П	40;40П
Масса 1м, кг	4,84	5,90	7,05	8,59	10,40	12,30	14,20	15,30	16,30	17,40	18,40	21,00	24,00	27,70	31,80	36,50	41,90	48,30
Масса балки двутавровой (ГОСТ 8239-89)
Номер двутавра	10	12	14	16	18	20	22	24	27	30	33	36	40
h/b	100/55	120/64	140/73	160/81	180/90	200/100	220/110	240/115	270/125	300/135	330/140	360/145	400/155
s/t	4,5/7,2	4,8/7,3	4,9/7,5	5,0/7,8	5,1/8,1	5,2/8,4	5,4/8,7	5,6/9,5	6,0/9,8	6,5/10,2	7/11,2	7,5/12,3	8,3/13
Масса 1м, кг	9,46	11,5	13,7	15,9	18,4	21,0	24,0	27,3	31,5	36,5	42,2	48,6	57,0
Масса круга (ГОСТ 2590-88)
Диаметр (мм)	5	5,5	6	6,3	6,5	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21
Масса 1м, кг	0,154	0,186	0,222	0,245	0,260	0,302	0,395	0,499	0,616	0,746	0,888	1,04	1,21	1,39	1,58	1,78	2,00	2,23	2,47	2,72
Диаметр (мм)	22	23	24	25	26	27	28	30	31	32	33	34	35	36	37	38	39	40	41	42
Масса 1м, кг	2,98	3,26	3,55	3,85	4,17	4,50	4,83	5,55	5,92	6,31	6,71	7,13	7,55	7,99	8,44	8,90	9,38	9,86	10,36	10,88
Диаметр (мм)	43	44	45	46	47	48	50	52	53	54	55	56	58	60	62	63	65	67	68	70
Масса 1м, кг	11,40	11,94	12,48	13,05	13,75	14,20	15,42	16,67	17,32	17,65	18,65	19,33	20,74	22,19	23,70	24,47	26,05	27,68	28,51	30,21
Диаметр (мм)	72	75	78	80	82	85	90	95	100	105	110	120	130	140	150	160	170	180	190	200
Масса 1м, кг	31,96	34,68	37,51	39,46	41,46	44,54	49,94	55,64	61,65	67,97	74,60	88,78	104,20	120,84	138,72	157,83	178,18	199,76	222,57	246,62
Масса шестегранников (ГОСТ 2879-88 и 8560-78)
Ф впис. круга (мм)	10	11	12	13	14	15	16	17	18	19	20	21	22	24	25	26	27	28	30	32
Масса 1м, кг	0,680	0,823	0,979	1,15	1,33	1,53	1,74	1,96	2,20	2,45	2,72	3,00	3,29	3,92	4,25	4,59	4,96	5,33	6,12	6,96
Ф впис.круга (мм)	34	38	40	41	42	45	46	48	50	53	55	56	60	63	65	70	75	80	85	90
Масса 1м, кг	7,86	8,81	9,82	10,88	11,40	11,99	14,40	15,66	16,99	19,10	20,60	21,32	24,50	26,98	28,70	33,30	38,24	43,51	49,12	55,07

RuntimeError: заданные группы = 1, вес [64, 3, 3, 3], поэтому ожидалось, что вход [16, 64, 256, 256] будет иметь 3 канала, но вместо этого получил 64 канала — зрение

яшкатария
(Яш Катария)

24 января 2018 г. , 4:12

1

Почему я получаю эту ошибку?

RuntimeError: заданные группы = 1, вес [64, 3, 3, 3], поэтому ожидалось, что ввод [16, 64, 256, 256] будет иметь 3 канала, но вместо этого получил 64 канала

Я написал реализацию U-net.

 класс double_conv(nn.Module):
  def __init__(самостоятельно, in_ch, out_ch):
    super(double_conv, self).__init__()
    self.conv1 = nn.Conv2d(in_ch, out_ch, 3, padding=1)
    self.conv2 = nn.Conv2d(in_ch, out_ch, 3, padding=1)
    
  защита вперед (я, х):
    x = F.relu (self.conv1 (x))
    x = F.relu (self.conv2 (x))
    вернуть х
  
  
класс input_conv(nn.Module):
  def __init__(самостоятельно, in_ch, out_ch):
    супер(input_conv, сам).__init__()
    self.inp_conv = double_conv(in_ch, out_ch)
    
  защита вперед (я, х):
    х = self.inp_conv(x)
    вернуть х
  
класс вверх (nn.Module):
  def __init__(самостоятельно, in_ch, out_ch):
    супер(вверх, я).__init__()
    self. up_conv = nn.ConvTranspose2d(in_ch, out_ch, kernel_size=2, шаг=2)
    self.conv = double_conv(in_ch, out_ch)
    
  защита вперед (я, x1, x2):
    x1 = self.up_conv(x1)
    х = torch.cat ([x2, x1], тусклый = 1)
    х = самоутверждение (х)
    вернуть х
    
    
класс вниз (nn.Module):
  def __init__(самостоятельно, in_ch, out_ch):
    супер(вниз, я).__init__()
    self.pool = nn.MaxPool2d(2)
    self.conv = double_conv(in_ch, out_ch)
    
  защита вперед (я, х):
    х = собственный пул (х)
    х = самоутверждение (х)
    вернуть х
  
класс last_conv(nn.Module):
  def __init__(самостоятельно, in_ch, out_ch):
    super(last_conv, self).__init__()
    self.conv1 = nn.Conv2d (in_ch, out_ch, 1)
    
  защита вперед (я, х):
    х = самоутверждение1 (х)
    вернуть х
класс Unet(nn.Module):
  def __init__(я, каналы, классы):
    супер(Unet, сам).__init__()
    self.inp = input_conv (каналы, 64)
    self.down1 = вниз (64, 128)
    self.down2 = вниз (128, 256)
    self.down3 = вниз (256, 512)
    self. down4 = вниз (512, 1024)
    self.up1 = вверх (1024, 512)
    self.up2 = вверх(512, 256)
    self.up3 = вверх(256, 128)
    self.up4 = вверх(128, 64)
    self.out = last_conv(64, классы)
    
  защита вперед (я, х):
    x1 = self.inp(x)
    x2 = self.down1 (x1)
    x3 = self.down2 (x2)
    x4 = self.down3 (x3)
    x5 = self.down4 (x4)
    х = self.up1 (x5, x4)
    х = self.up2 (х, х3)
    х = self.up3 (х, х2)
    х = self.up1 (х, х1)
    х = самовыход (х)
    вернуть х
модель = Унет (3, 1)
 

Это тренировочный цикл

 для эпохи в диапазоне (5):
    для i данные в enumerate (trainloader):
        входы, метки = данные
        входы = переменная (входы).cuda()
        метки = переменная (метки).cuda()
        
        # вперед + назад + оптимизация
        
        # обнуляет буферы градиента всех параметров
        оптимизатор.zero_grad()
        #проход вперед
        выходы = model_pytorch (входы)
        # рассчитать убыток
        потеря = функция_потери (выходные данные, метки)
        # обратное распространение
        потеря. назад()
        # Выполняет ли обновление после расчета градиентов
        оптимизатор.шаг()
        
        if (i+1) % 5 == 0: # печатать каждые 100 мини-пакетов
            print('[%d, %5d] потеря: %.4f' % (эпоха, i+1, loss.data[0]))
 

3 отметок «Нравится»

(Джунью)

24 января 2018 г., 5:19

2

Это означает, что ваш вход должен иметь 3 канала, но вы вводите 64 канала. Ввод организован в формате [N, C, W, H], ваш ввод, а также слой данных, должны иметь 3 канала. Вы должны проверить свой код.

1 Нравится

яшкатария
(Яш Катария)

24 января 2018 г., 5:24

3

Мой вход имеет 3 канала. Вход в Unet 3, 1, что соответствует 3 каналам и 1 классу.

СаймонВ
(Саймон Ван)

24 января 2018 г., 6:54

4

Я считаю, что ввод ответа @junyuseu означает ввод в конверсионный слой, а не ввод в фактическую работу сети. На самом деле, если ваш in_ch всегда равен out_ch, модуль double_conv обязательно выдаст такую ​​ошибку.

июнюсеу
(Джунью)

24 января 2018 г., 8:16

5

Ошибка здесь. В классе double_conv входной dim первого конверсионного слоя — in_ch(3), выходной dim — out_ch(64), второй конверсионный слой такой же, но входной dim этого слоя равен 64, а не in_ch(3)

10 лайков

яшкатария
(Яш Катария)

24 января 2018 г. , 12:46

6

Ага, глупая ошибка. Спасибо за помощь

Silva_Rubanza
(Сильва Рубанза)

16 мая 2019 г., 8:26

7

я получил такую ​​​​же ошибку времени выполнения «данные группы = 1, вес размера [64, 3, 7, 7], ожидаемый ввод [1, 4, 224, 224], чтобы иметь 3 канала, но получил 4 канала вместо «

Давно пытаюсь исправить, но не могу понять, где ошибка.
Это моя модель арки.

любая помощь будет оценена

птрблк

16 мая 2019 г., 11:05

8

Ваш ввод содержит 4 канала, в то время как первый конверсионный слой ожидает ввода с 3 каналами.
Если вы имеете дело с изображениями RGB, 4-й канал может быть альфа-каналом, который можно просто удалить.
Если вы используете пользовательский DataLoader , вы могли бы просто использовать:

 def __getitem__(self, index):
    img = Image.open(self.paths[index]).convert('RGB')
    ...
    # В качестве альтернативы удалите альфа-канал из тензора
    img = Image.open(self.paths[индекс])
    х = TF.to_tensor (изображение)
    х = х[:3]
    ...
 

7 лайков

aksg87
(Акшай Гоэль)

10 октября 2019 г., 00:35

9

Спасибо за ответ! У меня был другой, но связанный с этим вопрос.

Если вы имеете дело с 1-канальным изображением в градациях серого, но хотите использовать предварительно обученную сеть (я работаю над этим репозиторием на основе resnet18…

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

10 октября 2019 г. , 00:50

10

Думаю, это самый простой способ.
В качестве альтернативы вы также можете попробовать уменьшить количество каналов фильтра (среднее значение, сумма, ?) и посмотреть, может ли это повысить производительность (я еще не сравнивал эти подходы).

1 Нравится

гсс
(Гильермина)

1 декабря 2019 г., 3:34

11

Я получаю ту же ошибку. Любая идея, где это может быть в моем коде. Кажется, я не понимаю, где ошибка…

 класс CNN(nn.Module):
        защита __init__(сам):
            супер(CNN, сам).__init__()
            self.conv1 = nn.Conv2d(4, 7, (3, 3))
            # self.convnorm1 = nn.BatchNorm2d(7)
            # self.pool1 = nn.MaxPool2d((2, 2))
            self.conv2 = nn.Conv2d(7, 14, (3, 3))
            self.convnorm2 = nn. BatchNorm2d(14)
            # self.pool2 = nn.MaxPool2d((2, 2))
            #
            self.conv3 = nn.Conv2d(14, 28, (3, 3))
            # self.convnorm3 = nn.BatchNorm2d(28)
            # self.pool3 = nn.MaxPool2d((2, 2))
            self.conv4 = nn.Conv2d(28, 56, (3, 3))
            self.convnorm4 = nn.BatchNorm2d(56)
            # self.pool4 = nn.MaxPool2d((2, 2))
            self.conv5= nn.Conv2d(56, 112, (3, 3))
            self.convnorm5 = nn.BatchNorm2d(112)
            # self.pool5 = nn.MaxPool2d((2, 2))
            self.conv6 = nn.Conv2d(112, 224, (2, 2))
            self.convnorm6 = nn.BatchNorm2d(224)
            # self.pool6 = nn.MaxPool2d((2, 2))
            #
            # self.conv7 = nn.Conv2d(224, 448, (2, 2))
            # self.convnorm7 = nn.BatchNorm2d(448)
            # self.pool7 = nn.MaxPool2d((2, 2))
            self.linear1 = nn.Linear (47096, 200)
            self.linear1_bn = nn.BatchNorm1d (200)
            self.drop = nn.Dropout(DROPOUT)
            self. linear2 = nn.Linear (200, 17)
            self.act = факел.relu
        защита вперед (я, х):
            # x = self.act(self.conv1(x))
            # x = self.pool1(self.convnorm1(self.act(self.conv1(x))))
            #x = self.pool1(self.act(self.conv1(x)))
            х = self.act (self.conv1 (x))
            #x = self.pool2(self.convnorm2(self.act(self.conv2(x))))
            x = self.convnorm2 (self.act (self.conv2 (x)))
            х = self.act (self.conv3 (x))
            # x = self.pool3(self.convnorm3(self.act(self.conv3(x))))
            # x = self.pool4(self.convnorm4(self.act(self.conv4(x))))
            х = self.convnorm4 (self.act (self.conv4 (x)))
            # x = self.pool5(self.convnorm5(self.act(self.conv5(x))))
            # x = self.pool6(self.convnorm6(self.act(self.conv6(x))))
            # x = self.pool7(self.convnorm7(self.act(self.conv7(x))))
            x = self.drop((self.linear1_bn(self.act(self.linear1(x.view(len(x), -1))))))
            вернуть self.linear2 (x)
 

птрблкк

1 декабря 2019 г. , 3:51

12

Какая у вас форма ввода?
Код отлично работает, используя этот фрагмент:

 model = CNN()
x = факел.randn(2, 4, 37, 37)
выход = модель (х)
 

1 Нравится

(адарш пандей)

18 декабря 2019 г., 9:51

13

@ptrblck сэр, пожалуйста, объясните, что такое форма ввода … я забыл … а также … у меня похожая ошибка с моим кодом … пожалуйста, помогите мне понять это …
вот фрагмент::

import cv2
import torch
Импорт TORCH.NN AS NN
Import Torch.nn.functional As F
Import OS
из импортного изображения
Импорт. каскады

face_cascade =cv2.CascadeClassifier(«haarcascade_frontalface_default.xml»)
eye_cascade =cv2.CascadeClassifier(«haarcascade_eye.xml»)
#определить функцию, которая будет выполнять обнаружение . detectMultiScale (серый, 1.3,5)
для (x, y, w, h) в лицах:
cv2.rectangle (кадр, (x, y), (x + w, y + h), (255,0 ,0),2)
roi_gray=gray[y:y+h,x:x+w]
roi_color=frame[y:y+h,x:x+w]
eyes=eye_cascade.detectMultiScale(roi_gray,1.1 ,3)
для (ex,ey,ew,eh) в глазах:
cv2.rectangle(roi_color,(ex,ey),(ex+ew,ey+eh),(0,255,0),2)
возврат кадра
# применение функции обнаружения

class CNN(nn.Module):
def init (self,num_inputs):
super(CNN, self). init ()
self.conv1 = nn.Conv2d(num_inputs, 32, 3, шаг=2, заполнение=1)
self.conv2 = nn.Conv2d(32, 32, 3, шаг=2, заполнение=1) )
self.conv3 = nn.Conv2d(32, 32, 3, шаг=2, заполнение=1)
self.conv4 = nn.Conv2d(32, 32, 3, шаг=2, заполнение=1)
self.fc1 = nn.Linear(in_features =32 3 3 , out_features = 40)
self.fc2 = nn.Linear(in_features = 40, out_features = 2)
def forward(self,x):
x = F.relu(F.max_pool2d(self. conv1(x), 3, 2))
x = F.relu(F.max_pool2d(self.conv2(x), 3, 2))
x = F.relu( F.max_pool2d(self.conv3(x), 3, 2))
x = x.view(x.size(0), -1)
x = F.relu(self.fc1(x))
x = self.fc2(x)
return x
#обучить вашу нейронную сеть
cnn=CNN(3)#указать количество входных параметров

batchSize = 4 # Устанавливаем размер батча.
imageSize = 64 # Устанавливаем размер генерируемых изображений (64×64).
path=r»C:\Users\SHRIKANT\Music\Downloads\Simple_Linear_Regression\computer-vision\Module 3 — GANs»

#transform = transforms.Compose([transforms.Scale(imageSize), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),]) # Мы создаем список преобразований (масштабирование, тензорное преобразование, нормализация) для применения к входным изображениям.

#dataloader = torch.utils.data.DataLoader(dataset, batch_size = batchSize, shuffle = True, num_workers = 2) # Мы используем dataLoader для пакетного получения изображений тренировочного набора.
os.chdir(path)
loss = nn.MSELoss()

для эпохи в диапазоне (25):
#train to find adarsh ​​pandey

 для l в диапазоне (1,66):
      fak=Image.open(str(l)+".png").convert("RGB")
      img = Image.open(self.paths[индекс])
      х = TF.to_tensor (изображение)
      х = х[:3]
       # с открытым (str(l)+".png",'rb') как фак:
      input = Variable (torch.from_numpy (np.array (fak, dtype = 'uint8'))). unsqueeze (0)
      #np.array(img, dtype='uint8')
      вывод = cnn (ввод)
      оптимизатор = optim.Adam (cnn.parameters (), lr = 0,001)
      #что, если здесь был optimizer.zero_grad()?? какой-либо эффект ....... пожалуйста, проверьте это
      loss_error = потеря (выход, ввод)
      оптимизатор.zero_grad()
      
      loss_error.backward()
      оптимизатор.шаг()
  #тренинг по идентификации шубхи пандей
  
  
  #тренировка заканчивается здесь
  probs=F.softmax(выход)
  label=probs.multinomial()[0]
  печать (этикетка)
 

video_capture=cv2.VideoCapture(0)
#f_name=100
пока True:

 _,frame=video_capture. read()
серый = cv2.cvtColor (кадр, cv2.COLOR_BGR2GRAY)
холст = обнаружить (серый, рамка)
#os.chdir(путь)
#cv2.imwrite(str(f_name)+".png",frame)
cv2.imshow('Видео',холст)
#f_name=f_name+1
если cv2.waitKey(1) и 0xFF ==ord('q'):
    перерыв
 

video_capture.release()
cv2.destroyAllWindows()

ptrblck

18 декабря 2019 г., 19:11

14

Входная форма относится к форме ваших входных тензоров, которые вы передаете своей модели.
Напр. Модули nn.Conv2d ожидают 4-мерный тензор формы [batch_size,channels,height,width] .

Не могли бы вы удалить несвязанные фрагменты кода (например, каскад opencv и т. д.) и опубликовать (минимальный) фрагмент кода для воспроизведения вашей ошибки с использованием случайных входных данных, пожалуйста?

PS: Вы можете добавлять фрагменты кода, заключая их в три обратных кавычки «`

1 Нравится

(Аакаш Бхатия)

4 января 2020 г. , 5:53

15

класс LeNet(nn.Module):
def init (self):
super(LeNet, self). init ()
self.conv1 = nn.Conv2d(1, 6, 5,bias=False)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)

 def forward(self, x):
    выход = self.conv1(x)
    аут = F.relu (аут)
    выход = F.max_pool2d (выход, 2)
    выход = F.relu (self.conv2 (выход))
    выход = F.max_pool2d (выход, 2)
    выход = выход.просмотр(выход.размер(0), -1)
    аут = F.relu (self.fc1 (аут))
    аут = F.relu (self.fc2 (аут))
    аут = self.fc3(аут)
    вернуться
 

модель = LeNet().to(устройство=устройство)

if args.model:
if os.path.isfile(args.model):
print(«=> загрузка контрольной точки ‘{}'».format( аргументы.модель))
контрольная точка = torch.load(args.model)
args.start_epoch = контрольная точка[‘эпоха’]
best_prec1 = контрольная точка[‘best_prec1’]
model. load_state_dict(checkpoint[‘state_dict’])
print(«=> загружено контрольная точка ‘{}’ (эпоха {}) Prec1: {:f}».format(args.model, checkpoint[‘epoch’], best_prec1))
else:
print(«=> контрольная точка не найдена в ‘{} «».format(args.resume))

print(‘Предварительная обработка прошла успешно!’)

def test(model):
kwargs = {‘num_workers’: 1, ‘pin_memory’: True} if args.cuda еще {}
test_loader = torch.utils.data.DataLoader(
datasets.MNIST(‘./data’, train=True, download=True,
transform=transforms.Compose([
transforms.Resize((32, 32)),
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])),
batch_size=args.test_batch_size, shuffle=True, **kwargs)

получая эту ошибку: RuntimeError: Учитывая группы = 1, вес размера 3 6 5 5, ожидаемый ввод [256, 3, 14, 14] будет иметь 6 каналов, но вместо этого получил 3 канала
, если я изменю смещение = True, тогда я получаю эту ошибку:
RuntimeError: Учитывая вес размера 3 1 5 5, ожидаемое смещение будет одномерным с 3 элементами, но вместо этого получено смещение размера [6]

ptrblck

8 января 2020 г. , 8:35

16

Ответил здесь.

Мария_Фернанда_Де_Ла
(Мария Фернанда Де Ла Торре)

30 мая 2020 г., 14:10

17

Здравствуйте, у меня есть этот генератор наборов данных, и у меня возникает похожая проблема. Я пробовал то, что вы предложили, но получаю эту ошибку:

 return data[:3], target[:3], index
IndexError: недопустимый индекс скалярной переменной.
 

Знаете, почему это скаляр, а не тензор?

 класс MyDataset (набор данных):
    def __init__(я,remove_list):
        self.cifar10 = наборы данных.CIFAR10(root='./data',
                                        скачать = Ложь,
                                        поезд = правда,
                                        трансформировать = трансформировать)
        self.data = self.cifar10.data
        # self. data = np.vstack(self.data).reshape(-1, 3, 32, 32)
        # self.data = self.data.transpose((0, 2, 3, 1))
        self.targets = self.cifar10.targets
        self.final_data, self.final_targets = self.__remove__(remove_list)
      
    def __getitem__(я, индекс):
        данные, цель = self.final_data[индекс], self.final_targets[индекс]
        
        возвращаемые данные[:3], цель[:3], индекс
    защита __len__(я):
        вернуть len(self.final_data)
    def __remove__(я, remove_list):
        данные = np.delete (self.data, remove_list, ось = 0)
        цели = np.delete (self.targets, remove_list, ось = 0)
        
        возвращаемые данные, цели
 

птрблкк

30 мая 2020 г., 21:45

18

target может быть скаляром, так как вы вызываете self.final_targets с одним индексом.
Также данные должны быть одной выборкой, и я не уверен, что делает индексация [:3] .

Не могли бы вы немного объяснить свой вариант использования и чего вы пытаетесь достичь?

1 Нравится

Аншуман_Сенапати
(Аншуман Сенапати)

1 сентября 2020 г., 16:54

19

У меня очень похожая ошибка.

«Данные группы = 1, вес размера [10, 3, 7, 7], ожидаемый ввод [1, 64, 64, 3] будет иметь 3 канала, но вместо этого получил 64 канала»

Я понимаю, что ввод должен быть [партия, каналы, высота, ширина], но моя среда возвращает мне массивы размера (64, 64, 3). Как мне сделать это (3, 64, 64), ввести его в nn.Conv2d и обойти эту ошибку?

Пожалуйста, помогите. @ptrblck

1 сентября 2020 г. , 21:05

20

Если вы загружаете изображения, например, с помощью OpenCV , вы получите массив в форме [H, W, C] и вам нужно будет переставить его на [C, H, W] .
Если вы хотите выполнить эту перестановку в массиве numpy, вы можете использовать np.transpose , а tensor.permute следует использовать в PyTorch.

3 Likes

python — RuntimeError: заданные группы = 1, вес размера [64, 32, 3, 3], ожидаемый ввод [128, 64, 32, 32] будет иметь 32 канала, но вместо этого получил 64 канала

I Я пытаюсь поэкспериментировать с тем, почему у нас есть исчезающий и взрывающийся градиент, и почему Resnet так помогает избежать двух проблем, описанных выше. Поэтому я решил обучить простую сеть Convolution со многими слоями, просто чтобы узнать, почему модель LOSS увеличивается, когда я тренируюсь со многими слоями, например, 20 слоями. но в какой-то момент я получаю эту ошибку, я могу понять, в чем может быть проблема, но я знаю, что это из моей архитектуры модели.

 images.shape: torch.Size([128, 3, 32, 32])
-------------------------------------------------- -------------------------
RuntimeError Traceback (последний последний вызов)
 в <модуле>
      1 для изображений, метки в train_dl:
      2 print('images.shape:', images.shape)
----> 3 выхода = модель (изображения)
      4 print('out.shape:', out.shape)
      5 print('выход[0]:', выход[0])
/opt/conda/lib/python3.7/site-packages/torch/nn/modules/module.py в _call_impl(self, *input, **kwargs)
    725 результат = self._slow_forward(*input, **kwargs)
    726 еще:
--> 727 результат = self.forward(*input, **kwargs)
    728 для хука в itertools.chain(
    729_global_forward_hooks.values(),
 в пересылке (я, xb)
     31
     32 защиты вперед (на себя, xb):
---> 33 вернуть self.network(xb)
/opt/conda/lib/python3. 7/site-packages/torch/nn/modules/module.py в _call_impl(self, *input, **kwargs)
    725 результат = self._slow_forward(*input, **kwargs)
    726 еще:
--> 727 результат = self.forward(*input, **kwargs)
    728 для хука в itertools.chain(
    729_global_forward_hooks.values(),
/opt/conda/lib/python3.7/site-packages/torch/nn/modules/container.py в пересылке (я, ввод)
    115 по определению вперед (на себя, ввод):
    116 для модуля в себе:
--> 117 ввод = модуль (ввод)
    118 возврат ввода
    119
/opt/conda/lib/python3.7/site-packages/torch/nn/modules/module.py в _call_impl(self, *input, **kwargs)
    725 результат = self._slow_forward(*input, **kwargs)
    726 еще:
--> 727 результат = self.forward(*input, **kwargs)
    728 для хука в itertools.chain(
    729_global_forward_hooks.values(),
/opt/conda/lib/python3.7/site-packages/torch/nn/modules/conv.py в пересылке (я, ввод)
    421
    422 def forward(self, input: Tensor) -> Tensor:
--> 423 вернуть self._conv_forward(input, self.weight)
    424
    425 класс Conv3d(_ConvNd):
/opt/conda/lib/python3. 7/site-packages/torch/nn/modules/conv.py в _conv_forward(я, ввод, вес)
    418 _pair(0), само.расширение, само.группы)
    419 вернуть F.conv2d(ввод, вес, self.bias, self.stride,
--> 420 self.padding, self.dilation, self.groups)
    421
    422 def forward(self, input: Tensor) -> Tensor:
RuntimeError: заданные группы = 1, вес размера [64, 32, 3, 3], ожидаемый ввод [128, 64, 32, 32] будет иметь 32 канала, но вместо этого получил 64 канала
 

Моя модель Архитектура — это класс

 Cifar10CnnModel (ImageClassificationBase):
 защита __init__(сам):
 супер().__инит__()
 self.network = nn.Sequential(
 nn.Conv2d(3, 32, размер_ядра=3, заполнение=1),
 nn.Conv2d(32, 32, размер_ядра=3, заполнение=1),
 nn.ReLU(),
 nn.Conv2d(32, 64, размер_ядра=3, шаг=1, заполнение=1),
 nn.Conv2d(32, 64, размер_ядра=3, шаг=1, заполнение=1),
 nn.ReLU(),
 nn.MaxPool2d(2, 2), # вывод: 64 x 16 x 16
 nn.