Сергей Соколов

По вашей же ссылке, ниже, идёт описание формата файлов:

[offset] [type]          [value]          [description]
0000     32 bit integer  0x00000803(2051) magic number
0004     32 bit integer  60000            number of images
0008     32 bit integer  28               number of rows
0012     32 bit integer  28               number of columns
0016     unsigned byte   ??               pixel
0017     unsigned byte   ??               pixel
........
xxxx     unsigned byte   ??               pixel

Pixels are organized row-wise. Pixel values are 0 to 255. 0 means background (white), 255 means foreground (black).

Т.е. грубо говоря, можно проигнорировать заголовок, отмотать сразу на 16-й байт и прочитать 784 байта первой картинки. Каждый байт это яркость очередного серого (одноканального) пикселя: 0 белый, 255 черный.

В PHP

• открыть файл fopen() как бинарный ('b' нужно только в Windows): $fh = fopen('train-images-idx3-ubyte', 'rb');
  
• отмотать fseek() на 16-й байт:
  fseek( $fh, 16);
  
• Прочитать fread() 784 байта: $byteString = fread($fh, 784);
  

Дальше можете работать со строкой или распаковать unpack() байты:

$arr = unpack( 'C*', $byteString);
$arr[28] // яркость первого пикселя во второй строке

P.S. но с оптимизмом глядя в будущее, я бы порекомендовал заморочиться и освоить Python, т.к. для него на порядки больше библиотек, уроков и людей в теме машинного обучения.

Почитайте про то как работает градиентный спуск.

В процессе обучения вы минимизируете функцию потерь, ищете её дно:


«Скорость обучения» == «величина шага». Если слишком большие шаги, есть риск проскочить свою остановку. Если слишком маленькие – придёте, но пешком быстрее. : )

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

Зачем гадать, если можно измерить. Например.

в документации на MDN неплохо описано назначение сортировочной функции:

Если функция сравнения compareFunction предоставлена, элементы массива сортируются в соответствии с её возвращаемым значением. Если сравниваются два элемента a и b, то:

Если compareFunction(a, b) меньше 0, сортировка поставит a по меньшему индексу, чем b, то есть, a идёт первым.

Если compareFunction(a, b) вернёт 0, сортировка оставит a и b неизменными по отношению друг к другу, но отсортирует их по отношению ко всем другим элементам. Обратите внимание: стандарт ECMAscript не гарантирует данное поведение, и ему следуют не все браузеры (например, версии Mozilla по крайней мере, до 2003 года).

Если compareFunction(a, b) больше 0, сортировка поставит b по меньшему индексу, чем a.

Функция compareFunction(a, b) должна всегда возвращать одинаковое значение для определённой пары элементов a и b. Если будут возвращаться непоследовательные результаты, порядок сортировки будет не определён.

1. Найти корневой элемент – в вашем случае это с наименьшим id
   
2. Далее рекурсивно вызывать функцию, которая получая на вход элемент дописывает ему детей по их id.
   

Чтобы быстрее по id находить весь элемент, данные в начале преобразовываются в «словарь» – объект, где свойства это id, а значения элементы.

var data = [
{id: 0, name: 'Main', path: '/', childs: [1,2]},
{id: 1, name: 'One', path: '/one', childs: [3]},
{id: 2, name: 'Two', path: '/two', childs: []},
{id: 3, name: 'Three', path: '/one/three', childs: []}
];

function makeTree(d) {
  var id, el, i, dict = {}, minId, r;
  
  function parseChildren(el) {
    var i, newEl;
    for( i = 0; i < el.childs.length; i++) {
      newEl = makeElement(dict[ el.childs[i] ]);
      parseChildren( newEl);
      el.children.push( newEl);
    }
    delete el.childs;
  }
  
  for( i = 0; i < d.length; i++) {
    el = d[i];
    id = el.id;
    if( typeof minId === 'undefined' || minId > id) minId = id;
    dict[id] = el;
  }

  r = makeElement( dict[minId] ); // root element
  parseChildren(r);
  return r;
}

function makeElement(arrElement) {
  return {
    name: arrElement.name,
    path: arrElement.path,
    childs: arrElement.childs,
    children: []
  };
}

var tree = makeTree(data);
/* {
	"name": "Main",
	"path": "/",
	"children": [{
		"name": "One",
		"path": "/one",
		"children": [{
			"name": "Three",
			"path": "/one/three",
			"children": []
		}]
	}, {
		"name": "Two",
		"path": "/two",
		"children": []
	}]
} */

Создать объект со свойством areas:
var result = { "areas": "значение для areas"}

Взять массив из свойства "mh" исходных данных. Это запись в JSON поэтому просто пишем

peremennaya = {...тут весь этот JSON...}
peremennaya.mh // тут нужный массив

Из этого массива нужно сделать новый, где каждый элемент будет содержать только два свойства: id и title. Первое берется из оригинала как есть, а второе нужно составить, собрав значения свойств элемента title и count через пробел-дефис-пробел:
'' + el.title + ' - ' + el.count

Когда нужно над каждым элементом массива произвести какое действие, удобен метод массивов map(). В него передаётся функция, которая, получая на вход очередное значение из массива, что-то с ним делает и возвращает новое значение.

Итого:

var d = {"mh": [{"id": "BR", "count": 18516, "title": "Brazil"}, 
    {"id": "US", "count": 4514, "title": "United States"}, 
    {"id": "MY", "count": 390, "title": "Malaysia"}, 
    {"id": "IT", "count": 208, "title": "Italy"}]
};

var result = {areas: d.mh.map(el => ({id:el.id, title:''+el.title+' - '+el.count}))}

// {"areas":[{"id":"BR","title":"Brazil - 18516"},{"id":"US","title":"United States - 4514"},
//   {"id":"MY","title":"Malaysia - 390"},{"id":"IT","title":"Italy - 208"}]}

Недоделили. 1 квадратный метр это 1000*1000мм.
Полученные миллиметры надо делить на миллион.

Нашёл отличную шпаргалку, которая решает все мои вопросы: приложение к книге Sebastian Raschka «Introduction to Artificial Neural Networks and Deep Learning: A Practical Guide with Applications in Python»

sebastianraschka.com...appendix_a_math_notation.pdf

Ноутбуки книги на github: rasbt/deep-learning-book

Собрать из текста словарь "длина": [слово,слово]
Выбирать слова нужной длины, а при отсутствии смотреть соседние по значению ключи.

words = txt.replace(/[\.,\?\!\:;\–\(\)]/g, '').toLowerCase().split(/\s+/);

// make dictionary
var db = [];
for( var i = 0; i < words.length; i++) {
  word = words[i];
  len = word.length;
  if(db.length <= len || typeof db[len] == 'undefined') db[len] = [];
  if(!~db[len].indexOf(word)) db[len].push(word);
}

function getWords(db, length, n) {
  n = n || 3;
  var result = [], offset = 0, m;
  length = Math.max(0, Math.min(length, db.length));
  while( result.length < n) {

    m = n - result.length;
    if( db[length + offset]) {
      result = result.concat( getUpTo(m, db[length + offset]))
    }

    m = n - result.length;
    if( offset &&  m  &&  db[length - offset]) {
      result = result.concat( getUpTo(m, db[length - offset]))
    }
    
    m = n - result.length;
    if( m === 0) break;
    offset++;
    if( offset + length > db.length && offset > length) break;
  }
  
  return result;
}

function getUpTo(n, arr) {
  return arr.slice(0, Math.min(n, arr.length));
}

Fiddle