cross validation from scratch.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Implementation of  k-cross validation \n",
    "  Restrictions: \n",
    "      1. The length of k splits can only differ by 1 \n",
    "      2. The classes should be distributed equally between the k splits (difference again only max 1)\n",
    "\n",
    "    input: data matrice and label array\n",
    "    output: k splits for data and label\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import random\n",
    "\n",
    "# metavalues for testing \n",
    "Nclasses = 4\n",
    "Nobjects = 100\n",
    "inputLabel= np.random.randint(Nclasses, size=Nobjects) #or \n",
    "inputLabel= np.array([0,0,0,0,1,1,1,2,2,3]) # For specific example. please start with first class = 0\n",
    "\n",
    "k = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cross_validation_split(label,k,Nclasses,shuffle=True):      #creates a new shape for the data (index list)\n",
    "    label_split = [[] for _ in range(k)]\n",
    "    classL = {}\n",
    "    Nclasses = len(set(label))\n",
    "    for z in range (Nclasses): #sort classes in order to secure class balance in the k_split\n",
    "        currentLabel = []\n",
    "        for x in range (len(label)):\n",
    "            if label[x] == z: \n",
    "                currentLabel.append(x)\n",
    "        classL[z] = currentLabel\n",
    "    print(classL) #here is how the class split looks like\n",
    "        \n",
    "    remain = []    \n",
    "    for w in range (len(classL)):  #find minimum number of elements of a class that have to be included in every k\n",
    "        fold_size = int(len(classL[w]) / k) \n",
    "        label_copy = classL[w]\n",
    "        \n",
    "        for x in range(k):     #fill min number of class elements in every k that can be equally distributed\n",
    "            fold = list()\n",
    "            while len(fold) < fold_size :\n",
    "                index = random.randrange(len(label_copy))\n",
    "                fold.append(label_copy.pop(index))\n",
    "            label_split[x]= label_split[x] + fold\n",
    "        for element in label_copy:   \n",
    "            remain.append(element)       #keep the not yet distributed elements \n",
    "            \n",
    "    start = random.randrange(k)        # To keep the distribution random. Otherwise first k always gets lowest remaining class\n",
    "    for v in range(len(remain)):  # distribute remaining elements in order to secure equal k length\n",
    "        label_split[(v+start)%k].append(remain[v]) \n",
    "                \n",
    "    if shuffle == True:          # shuffle data. If not activated, the indices are are somehow ordered by class in every k (e.g. first class in every k is always from class 0)\n",
    "            for e in label_split: \n",
    "                random.shuffle(e)  \n",
    "    return label_split  \n",
    "        \n",
    "    \n",
    "                "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: [0, 1, 2, 3], 1: [4, 5, 6], 2: [7, 8], 3: [9]}\n",
      "[[2, 5, 1, 9], [0, 4, 7], [3, 6, 8]]\n"
     ]
    }
   ],
   "source": [
    "#Final split for the different k's\n",
    "split = cross_validation_split(inputLabel,k,Nclasses,False)    \n",
    "print(split)\n",
    "\n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-----------------------------------------------------------------------------------------------------------\n",
    "-----------------------------------------------------------------------------------------------------------\n",
    "-----------------------------------------------------------------------------------------------------------\n",
    "-----------------------------------------------------------------------------------------------------------\n",
    "-----------------------------------------------------------------------------------------------------------\n",
    "-----------------------------------------------------------------------------------------------------------\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# For sorting the final labels and random generated data according to the split\n",
    "#(Not relevant for the exercise)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[list([array([3, 2]), array([0, 0]), array([0, 1]), array([1, 3])])\n",
      " list([array([3, 0]), array([3, 2]), array([2, 2])])\n",
      " list([array([3, 0]), array([2, 1]), array([0, 3])])] [list([0, 1, 0, 3]) list([0, 1, 2]) list([0, 1, 2])]\n"
     ]
    }
   ],
   "source": [
    "def data_align(indices,toSort):              \n",
    "    sorted_split =[]\n",
    "    for x in range(len(indices)):\n",
    "        holder = []\n",
    "        for z in range(len(indices[x])):\n",
    "            holder.append(toSort[indices[x][z]])\n",
    "        sorted_split.append(holder)\n",
    "        \n",
    "    return np.array(sorted_split)\n",
    "\n",
    "dataDimension = 2\n",
    "inputD = np.random.randint(Nclasses, size=(Nobjects,dataDimension))\n",
    "k_data = data_align(split,inputD)\n",
    "k_label = data_align(split,inputLabel)\n",
    "print(k_data,k_label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}