Use exact same structure as example

.gitattributes

@@ -17,12 +17,15 @@
 *.pt filter=lfs diff=lfs merge=lfs -text
 *.pth filter=lfs diff=lfs merge=lfs -text
 *.rar filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text 
 *.tar.* filter=lfs diff=lfs merge=lfs -text
 *.tflite filter=lfs diff=lfs merge=lfs -text
 *.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
 *.xz filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zstandard filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+variables.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+variables filter=lfs diff=lfs merge=lfs -text
+/Users/mervenoyan/Desktop/seg/pet-segmentation/variables/variables.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+variables.index filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,5 +1,32 @@
 ---
 tags:
-- text-classification
+- image-segmentation
+- generic
+library_name: generic
+dataset:
+- oxfort-iit pets
+widget:
+- src: https://huggingface.co/datasets/mishig/sample_images/resolve/main/cat-1.jpg
+  example_title: Kedis
+- src: https://huggingface.co/datasets/mishig/sample_images/resolve/main/cat-2.jpg
+  example_title: Cat in a Crate
+- src: https://huggingface.co/datasets/mishig/sample_images/resolve/main/cat-3.jpg
+  example_title: Two Cats Chilling
+license: cc0-1.0
 ---
-Test
+## Keras semantic segmentation models on the 🤗Hub! 🐶 🐕 🐩 
+Full credits go to [François Chollet](https://twitter.com/fchollet).
+
+This repository contains the model from [this notebook on segmenting pets using U-net-like architecture](https://keras.io/examples/vision/oxford_pets_image_segmentation/). We've changed the inference part to enable segmentation widget on the Hub. (see ```pipeline.py```)
+
+## Background Information 
+
+Image classification task tells us about a class assigned to an image, and object detection task creates a boundary box on an object in an image. But what if we want to know about the shape of the image? Segmentation models helps us segment images and reveal their shapes. It has many variants, including, panoptic segmentation, instance segmentation and semantic segmentation.This post is on hosting your Keras semantic segmentation models on Hub.
+Semantic segmentation models classify pixels, meaning, they assign a class (can be cat or dog) to each pixel. The output of a model looks like following.
+![Raw Output](./raw_output.jpg)
+We need to get the best prediction for every pixel.
+![Mask](./mask.jpg)
+This is still not readable. We have to convert this into different binary masks for each class and convert to a readable format by converting each mask into base64. We will return a list of dicts, and for each dictionary, we have the label itself, the base64 code and a score (semantic segmentation models don't return a score, so we have to return 1.0 for this case). You can find the full implementation in ```pipeline.py```.
+![Binary Mask](./binary_mask.jpg)
+Now that you know the expected output by the model, you can host your Keras segmentation models (and other semantic segmentation models) in the similar fashion. Try it yourself and host your segmentation models!
+![Segmented Cat](./hircin_the_cat.png)

added_tokens.json

@@ -1 +0,0 @@
-{"NUMBER_PERCENTAGE_TOKEN": 30525, "HYPHENATED_URL_TOKEN": 30524, "START_SELFPROMO_TOKEN": 30536, "START_SPONSOR_TOKEN": 30534, "PROFANITY_TOKEN": 30532, "[Laughter]": 30531, "BETWEEN_SEGMENTS_TOKEN": 30540, "NUMBER_TOKEN": 30526, "SHORT_HYPHENATED_TOKEN": 30527, "END_SPONSOR_TOKEN": 30535, "LONG_WORD_TOKEN": 30528, "EXTRACT_SEGMENTS: ": 30522, "END_INTERACTION_TOKEN": 30539, "[Applause]": 30530, "START_INTERACTION_TOKEN": 30538, "END_SELFPROMO_TOKEN": 30537, "URL_TOKEN": 30523, "NO_SEGMENT_TOKEN": 30533, "[Music]": 30529}

config.json

@@ -2,15 +2,6 @@
   "id2label": {
     "0": 0,
     "1": 1,
-    "2": 2,
-    "3": 3
-  },
-  "label2id": {
-    "0": 0,
-    "1": 1,
-    "2": 2,
-    "3": 3
-  },
-  "model_type": "bert",
-  "vocab_size": 30541
-}
+    "2": 2
+   }
+}

custom_pipeline.py

@@ -0,0 +1,333 @@
+import youtube_transcript_api2
+import json
+import re
+import requests
+from transformers import (
+    AutoModelForSequenceClassification,
+    AutoTokenizer,
+    TextClassificationPipeline,
+)
+from typing import Any, Dict, List
+
+CATEGORIES = [None, 'SPONSOR', 'SELFPROMO', 'INTERACTION']
+
+PROFANITY_RAW = '[ __ ]'  # How YouTube transcribes profanity
+PROFANITY_CONVERTED = '*****'  # Safer version for tokenizing
+
+NUM_DECIMALS = 3
+
+# https://www.fincher.org/Utilities/CountryLanguageList.shtml
+# https://lingohub.com/developers/supported-locales/language-designators-with-regions
+LANGUAGE_PREFERENCE_LIST = ['en-GB', 'en-US', 'en-CA', 'en-AU', 'en-NZ', 'en-ZA',
+                            'en-IE', 'en-IN', 'en-JM', 'en-BZ', 'en-TT', 'en-PH', 'en-ZW',
+                            'en']
+
+
+def parse_transcript_json(json_data, granularity):
+    assert json_data['wireMagic'] == 'pb3'
+
+    assert granularity in ('word', 'chunk')
+
+    # TODO remove bracketed words?
+    # (kiss smacks)
+    # (upbeat music)
+    # [text goes here]
+
+    # Some manual transcripts aren't that well formatted... but do have punctuation
+    # https://www.youtube.com/watch?v=LR9FtWVjk2c
+
+    parsed_transcript = []
+
+    events = json_data['events']
+
+    for event_index, event in enumerate(events):
+        segments = event.get('segs')
+        if not segments:
+            continue
+
+        # This value is known (when phrase appears on screen)
+        start_ms = event['tStartMs']
+        total_characters = 0
+
+        new_segments = []
+        for seg in segments:
+            # Replace \n, \t, etc. with space
+            text = ' '.join(seg['utf8'].split())
+
+            # Remove zero-width spaces and strip trailing and leading whitespace
+            text = text.replace('\u200b', '').replace('\u200c', '').replace(
+                '\u200d', '').replace('\ufeff', '').strip()
+
+            # Alternatively,
+            # text = text.encode('ascii', 'ignore').decode()
+
+            # Needed for auto-generated transcripts
+            text = text.replace(PROFANITY_RAW, PROFANITY_CONVERTED)
+
+            if not text:
+                continue
+
+            offset_ms = seg.get('tOffsetMs', 0)
+
+            new_segments.append({
+                'text': text,
+                'start': round((start_ms + offset_ms)/1000, NUM_DECIMALS)
+            })
+
+            total_characters += len(text)
+
+        if not new_segments:
+            continue
+
+        if event_index < len(events) - 1:
+            next_start_ms = events[event_index + 1]['tStartMs']
+            total_event_duration_ms = min(
+                event.get('dDurationMs', float('inf')), next_start_ms - start_ms)
+        else:
+            total_event_duration_ms = event.get('dDurationMs', 0)
+
+        # Ensure duration is non-negative
+        total_event_duration_ms = max(total_event_duration_ms, 0)
+
+        avg_seconds_per_character = (
+            total_event_duration_ms/total_characters)/1000
+
+        num_char_count = 0
+        for seg_index, seg in enumerate(new_segments):
+            num_char_count += len(seg['text'])
+
+            # Estimate segment end
+            seg_end = seg['start'] + \
+                (num_char_count * avg_seconds_per_character)
+
+            if seg_index < len(new_segments) - 1:
+                # Do not allow longer than next
+                seg_end = min(seg_end, new_segments[seg_index+1]['start'])
+
+            seg['end'] = round(seg_end, NUM_DECIMALS)
+            parsed_transcript.append(seg)
+
+    final_parsed_transcript = []
+    for i in range(len(parsed_transcript)):
+
+        word_level = granularity == 'word'
+        if word_level:
+            split_text = parsed_transcript[i]['text'].split()
+        elif granularity == 'chunk':
+            # Split on space after punctuation
+            split_text = re.split(
+                r'(?<=[.!?,-;])\s+', parsed_transcript[i]['text'])
+            if len(split_text) == 1:
+                split_on_whitespace = parsed_transcript[i]['text'].split()
+
+                if len(split_on_whitespace) >= 8:  # Too many words
+                    # Rather split on whitespace instead of punctuation
+                    split_text = split_on_whitespace
+                else:
+                    word_level = True
+        else:
+            raise ValueError('Unknown granularity')
+
+        segment_end = parsed_transcript[i]['end']
+        if i < len(parsed_transcript) - 1:
+            segment_end = min(segment_end, parsed_transcript[i+1]['start'])
+
+        segment_duration = segment_end - parsed_transcript[i]['start']
+
+        num_chars_in_text = sum(map(len, split_text))
+
+        num_char_count = 0
+        current_offset = 0
+        for s in split_text:
+            num_char_count += len(s)
+
+            next_offset = (num_char_count/num_chars_in_text) * segment_duration
+
+            word_start = round(
+                parsed_transcript[i]['start'] + current_offset, NUM_DECIMALS)
+            word_end = round(
+                parsed_transcript[i]['start'] + next_offset, NUM_DECIMALS)
+
+            # Make the reasonable assumption that min wps is 1.5
+            final_parsed_transcript.append({
+                'text': s,
+                'start': word_start,
+                'end': min(word_end, word_start + 1.5) if word_level else word_end
+            })
+            current_offset = next_offset
+
+    return final_parsed_transcript
+
+
+def list_transcripts(video_id):
+    try:
+        return youtube_transcript_api2.YouTubeTranscriptApi.list_transcripts(video_id)
+    except json.decoder.JSONDecodeError:
+        return None
+
+
+WORDS_TO_REMOVE = [
+    '[Music]'
+    '[Applause]'
+    '[Laughter]'
+]
+
+
+def get_words(video_id, transcript_type='auto', fallback='manual', filter_words_to_remove=True, granularity='word'):
+    """Get parsed video transcript with caching system
+    returns None if not processed yet and process is False
+    """
+
+    raw_transcript_json = None
+    try:
+        transcript_list = list_transcripts(video_id)
+
+        if transcript_list is not None:
+            if transcript_type == 'manual':
+                ts = transcript_list.find_manually_created_transcript(
+                    LANGUAGE_PREFERENCE_LIST)
+            else:
+                ts = transcript_list.find_generated_transcript(
+                    LANGUAGE_PREFERENCE_LIST)
+            raw_transcript = ts._http_client.get(
+                f'{ts._url}&fmt=json3').content
+            if raw_transcript:
+                raw_transcript_json = json.loads(raw_transcript)
+
+    except (youtube_transcript_api2.TooManyRequests, youtube_transcript_api2.YouTubeRequestFailed):
+        raise  # Cannot recover from these errors and do not mark as empty transcript
+
+    except requests.exceptions.RequestException:  # Can recover
+        return get_words(video_id, transcript_type, fallback, granularity)
+
+    except youtube_transcript_api2.CouldNotRetrieveTranscript:  # Retrying won't solve
+        pass  # Mark as empty transcript
+
+    except json.decoder.JSONDecodeError:
+        return get_words(video_id, transcript_type, fallback, granularity)
+
+    if not raw_transcript_json and fallback is not None:
+        return get_words(video_id, transcript_type=fallback, fallback=None, granularity=granularity)
+
+    if raw_transcript_json:
+        processed_transcript = parse_transcript_json(
+            raw_transcript_json, granularity)
+        if filter_words_to_remove:
+            processed_transcript = list(
+                filter(lambda x: x['text'] not in WORDS_TO_REMOVE, processed_transcript))
+    else:
+        processed_transcript = raw_transcript_json  # Either None or []
+
+    return processed_transcript
+
+
+def word_start(word):
+    return word['start']
+
+
+def word_end(word):
+    return word.get('end', word['start'])
+
+
+def extract_segment(words, start, end, map_function=None):
+    """Extracts all words with time in [start, end]"""
+
+    a = max(binary_search_below(words, 0, len(words), start), 0)
+    b = min(binary_search_above(words, -1, len(words) - 1, end) + 1, len(words))
+
+    to_transform = map_function is not None and callable(map_function)
+
+    return [
+        map_function(words[i]) if to_transform else words[i] for i in range(a, b)
+    ]
+
+
+def avg(*items):
+    return sum(items)/len(items)
+
+
+def binary_search_below(transcript, start_index, end_index, time):
+    if start_index >= end_index:
+        return end_index
+
+    middle_index = (start_index + end_index) // 2
+    middle = transcript[middle_index]
+    middle_time = avg(word_start(middle), word_end(middle))
+
+    if time <= middle_time:
+        return binary_search_below(transcript, start_index, middle_index, time)
+    else:
+        return binary_search_below(transcript, middle_index + 1, end_index, time)
+
+
+def binary_search_above(transcript, start_index, end_index, time):
+    if start_index >= end_index:
+        return end_index
+
+    middle_index = (start_index + end_index + 1) // 2
+    middle = transcript[middle_index]
+    middle_time = avg(word_start(middle), word_end(middle))
+
+    if time >= middle_time:
+        return binary_search_above(transcript, middle_index, end_index, time)
+    else:
+        return binary_search_above(transcript, start_index, middle_index - 1, time)
+
+
+class SponsorBlockClassificationPipeline(TextClassificationPipeline):
+    def __init__(self, model, tokenizer):
+        super().__init__(model=model, tokenizer=tokenizer, return_all_scores=True)
+
+    def preprocess(self, video, **tokenizer_kwargs):
+
+        words = get_words(video['video_id'])
+        segment_words = extract_segment(words, video['start'], video['end'])
+        text = ' '.join(x['text'] for x in segment_words)
+
+        model_inputs = self.tokenizer(
+            text, return_tensors=self.framework, **tokenizer_kwargs)
+        return {'video': video, 'model_inputs': model_inputs}
+
+    def _forward(self, data):
+        model_outputs = self.model(**data['model_inputs'])
+        return {'video': data['video'], 'model_outputs': model_outputs}
+
+    def postprocess(self, data, function_to_apply=None, return_all_scores=False):
+        model_outputs = data['model_outputs']
+
+        results = super().postprocess(model_outputs, function_to_apply, return_all_scores)
+
+        for result in results:
+            result['label_text'] = CATEGORIES[result['label']]
+
+        return results # {**data['video'], 'result': results}
+
+
+# model_id = "Xenova/sponsorblock-classifier-v2"
+# model = AutoModelForSequenceClassification.from_pretrained(model_id)
+# tokenizer = AutoTokenizer.from_pretrained(model_id)
+
+# pl = SponsorBlockClassificationPipeline(model=model, tokenizer=tokenizer)
+data = [{
+    'video_id': 'pqh4LfPeCYs',
+    'start': 835.933,
+    'end': 927.581,
+    'category': 'sponsor'
+}]
+# print(pl(data))
+
+# MODEL_ID = "Xenova/sponsorblock-classifier-v2"
+class PreTrainedPipeline():
+    def __init__(self, path: str):
+        # load the model
+        self.model = AutoModelForSequenceClassification.from_pretrained(path)
+        self.tokenizer = AutoTokenizer.from_pretrained(path)
+        self.pipeline = SponsorBlockClassificationPipeline(
+            model=self.model, tokenizer=self.tokenizer)
+
+    def __call__(self, inputs: str) -> List[Dict[str, Any]]:
+        json_data = json.loads(inputs)
+        return self.pipeline(json_data)
+
+# a = PreTrainedPipeline('Xenova/sponsorblock-classifier-v2')(json.dumps(data))
+# print(a)

rng_state.pth → keras_metadata.pb

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:341b9fac5e4ef18cdbcc0f24ef9702f00339086845194584ef728d46e5bb3aac
-size 14439
+oid sha256:e7844f7cdd94bacbd2dceb2000b172c07e3a3db345cd29ea0d51d66107ff28e9
+size 563033

pipeline.py

@@ -1,14 +1,78 @@
+import json
 from typing import Any, Dict, List
 
+import tensorflow as tf
+from tensorflow import keras
+import base64
+import io
+import os
+import numpy as np
+from PIL import Image
+
+
+
 class PreTrainedPipeline():
     def __init__(self, path: str):
         # load the model
-        self.model = None
+        self.model = keras.models.load_model(os.path.join(path, "tf_model.h5"))
+
+    def __call__(self, inputs: "Image.Image")-> List[Dict[str, Any]]:
+
+        # convert img to numpy array, resize and normalize to make the prediction
+        img = np.array(inputs)
+
+        im = tf.image.resize(img, (128, 128))
+        im = tf.cast(im, tf.float32) / 255.0
+        pred_mask = self.model.predict(im[tf.newaxis, ...])
+        
+        # take the best performing class for each pixel
+        # the output of argmax looks like this [[1, 2, 0], ...]
+        pred_mask_arg = tf.argmax(pred_mask, axis=-1)
+
+        labels = []
+        
+        # convert the prediction mask into binary masks for each class
+        binary_masks = {}
+        mask_codes = {}
+        
+        # when we take tf.argmax() over pred_mask, it becomes a tensor object
+        # the shape becomes TensorShape object, looking like this TensorShape([128]) 
+        # we need to take get shape, convert to list and take the best one
+        
+        rows = pred_mask_arg[0][1].get_shape().as_list()[0]
+        cols = pred_mask_arg[0][2].get_shape().as_list()[0]
+        
+        for cls in range(pred_mask.shape[-1]):
+
+            binary_masks[f"mask_{cls}"] = np.zeros(shape = (pred_mask.shape[1], pred_mask.shape[2])) #create masks for each class
+            
+            for row in range(rows):
+
+                for col in range(cols):
+
+                    if pred_mask_arg[0][row][col] == cls:
+                        
+                        binary_masks[f"mask_{cls}"][row][col] = 1
+                    else:
+                        binary_masks[f"mask_{cls}"][row][col] = 0
+
+            mask = binary_masks[f"mask_{cls}"]
+            mask *= 255
+            img = Image.fromarray(mask.astype(np.int8), mode="L")
+               
+            # we need to make it readable for the widget
+            with io.BytesIO() as out:
+                img.save(out, format="PNG")
+                png_string = out.getvalue()
+                mask = base64.b64encode(png_string).decode("utf-8")
 
-    def __call__(self, inputs: str) -> List[Dict[str, Any]]:
+            mask_codes[f"mask_{cls}"] = mask
+    
 
-        return [{
-                "label": 0,
-                "mask": 1,
+            # widget needs the below format, for each class we return label and mask string
+            labels.append({
+                "label": f"LABEL_{cls}",
+                "mask": mask_codes[f"mask_{cls}"],
                 "score": 1.0,
-                }]
+            })
+        return labels

special_tokens_map.json

@@ -1 +0,0 @@
-{"unk_token": "[UNK]", "sep_token": "[SEP]", "pad_token": "[PAD]", "cls_token": "[CLS]", "mask_token": "[MASK]"}

scheduler.pt → tf_model.h5

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:950d6c7290e92072e8c7281edabc31c607439497fc3ee6bbfd903b99ea82e72f
-size 623
+oid sha256:0258ea75c11d977fae78f747902e48541c5e6996d3d5c700175454ffeb42aa0f
+size 63661584

tokenizer_config.json

@@ -1 +0,0 @@
-{"do_lower_case": true, "unk_token": "[UNK]", "sep_token": "[SEP]", "pad_token": "[PAD]", "cls_token": "[CLS]", "mask_token": "[MASK]", "tokenize_chinese_chars": true, "strip_accents": null, "model_max_length": 512, "special_tokens_map_file": null, "name_or_path": "models/classifier-85000", "tokenizer_class": "BertTokenizer"}

trainer_state.json

@@ -1,379 +0,0 @@
-{
-  "best_metric": null,
-  "best_model_checkpoint": null,
-  "epoch": 1.8509766855702583,
-  "global_step": 235000,
-  "is_hyper_param_search": false,
-  "is_local_process_zero": true,
-  "is_world_process_zero": true,
-  "log_history": [
-    {
-      "epoch": 0.04,
-      "learning_rate": 1.921235034656585e-05,
-      "loss": 0.3334,
-      "step": 5000
-    },
-    {
-      "epoch": 0.08,
-      "learning_rate": 1.8424700693131696e-05,
-      "loss": 0.3387,
-      "step": 10000
-    },
-    {
-      "epoch": 0.12,
-      "learning_rate": 1.7637051039697544e-05,
-      "loss": 0.3327,
-      "step": 15000
-    },
-    {
-      "epoch": 0.16,
-      "learning_rate": 1.684940138626339e-05,
-      "loss": 0.3492,
-      "step": 20000
-    },
-    {
-      "epoch": 0.2,
-      "learning_rate": 1.606175173282924e-05,
-      "loss": 0.3349,
-      "step": 25000
-    },
-    {
-      "epoch": 0.2,
-      "eval_accuracy": 0.9155995845794678,
-      "eval_loss": 0.389266699552536,
-      "eval_runtime": 551.1932,
-      "eval_samples_per_second": 51.289,
-      "eval_steps_per_second": 12.823,
-      "step": 25000
-    },
-    {
-      "epoch": 0.24,
-      "learning_rate": 1.5274102079395087e-05,
-      "loss": 0.3279,
-      "step": 30000
-    },
-    {
-      "epoch": 0.28,
-      "learning_rate": 1.4486452425960932e-05,
-      "loss": 0.3301,
-      "step": 35000
-    },
-    {
-      "epoch": 0.32,
-      "learning_rate": 1.369880277252678e-05,
-      "loss": 0.3243,
-      "step": 40000
-    },
-    {
-      "epoch": 0.35,
-      "learning_rate": 1.2911153119092628e-05,
-      "loss": 0.293,
-      "step": 45000
-    },
-    {
-      "epoch": 0.39,
-      "learning_rate": 1.2123503465658477e-05,
-      "loss": 0.3053,
-      "step": 50000
-    },
-    {
-      "epoch": 0.39,
-      "eval_accuracy": 0.9235231876373291,
-      "eval_loss": 0.3810465931892395,
-      "eval_runtime": 542.4272,
-      "eval_samples_per_second": 52.118,
-      "eval_steps_per_second": 13.03,
-      "step": 50000
-    },
-    {
-      "epoch": 0.43,
-      "learning_rate": 1.1335853812224324e-05,
-      "loss": 0.3126,
-      "step": 55000
-    },
-    {
-      "epoch": 0.47,
-      "learning_rate": 1.0548204158790173e-05,
-      "loss": 0.3072,
-      "step": 60000
-    },
-    {
-      "epoch": 0.51,
-      "learning_rate": 9.760554505356018e-06,
-      "loss": 0.2957,
-      "step": 65000
-    },
-    {
-      "epoch": 0.55,
-      "learning_rate": 8.972904851921865e-06,
-      "loss": 0.2968,
-      "step": 70000
-    },
-    {
-      "epoch": 0.59,
-      "learning_rate": 8.185255198487714e-06,
-      "loss": 0.2882,
-      "step": 75000
-    },
-    {
-      "epoch": 0.59,
-      "eval_accuracy": 0.9224973320960999,
-      "eval_loss": 0.37537074089050293,
-      "eval_runtime": 521.9317,
-      "eval_samples_per_second": 54.164,
-      "eval_steps_per_second": 13.542,
-      "step": 75000
-    },
-    {
-      "epoch": 0.63,
-      "learning_rate": 7.3976055450535615e-06,
-      "loss": 0.2754,
-      "step": 80000
-    },
-    {
-      "epoch": 0.67,
-      "learning_rate": 6.6099558916194085e-06,
-      "loss": 0.2607,
-      "step": 85000
-    },
-    {
-      "epoch": 0.71,
-      "learning_rate": 5.8223062381852555e-06,
-      "loss": 0.2818,
-      "step": 90000
-    },
-    {
-      "epoch": 0.75,
-      "learning_rate": 5.034656584751103e-06,
-      "loss": 0.2736,
-      "step": 95000
-    },
-    {
-      "epoch": 0.79,
-      "learning_rate": 4.24700693131695e-06,
-      "loss": 0.2644,
-      "step": 100000
-    },
-    {
-      "epoch": 0.79,
-      "eval_accuracy": 0.9297842383384705,
-      "eval_loss": 0.3645715117454529,
-      "eval_runtime": 521.9055,
-      "eval_samples_per_second": 54.167,
-      "eval_steps_per_second": 13.543,
-      "step": 100000
-    },
-    {
-      "epoch": 0.83,
-      "learning_rate": 3.459357277882798e-06,
-      "loss": 0.2552,
-      "step": 105000
-    },
-    {
-      "epoch": 0.87,
-      "learning_rate": 2.6717076244486457e-06,
-      "loss": 0.266,
-      "step": 110000
-    },
-    {
-      "epoch": 0.91,
-      "learning_rate": 1.884057971014493e-06,
-      "loss": 0.2684,
-      "step": 115000
-    },
-    {
-      "epoch": 0.95,
-      "learning_rate": 1.0964083175803404e-06,
-      "loss": 0.2501,
-      "step": 120000
-    },
-    {
-      "epoch": 0.98,
-      "learning_rate": 3.087586641461878e-07,
-      "loss": 0.273,
-      "step": 125000
-    },
-    {
-      "epoch": 0.98,
-      "eval_accuracy": 0.9299964904785156,
-      "eval_loss": 0.3369257152080536,
-      "eval_runtime": 522.7551,
-      "eval_samples_per_second": 54.079,
-      "eval_steps_per_second": 13.521,
-      "step": 125000
-    },
-    {
-      "epoch": 1.02,
-      "learning_rate": 1.7952110901071204e-05,
-      "loss": 0.2834,
-      "step": 130000
-    },
-    {
-      "epoch": 1.06,
-      "learning_rate": 1.787334593572779e-05,
-      "loss": 0.3047,
-      "step": 135000
-    },
-    {
-      "epoch": 1.1,
-      "learning_rate": 1.7794580970384373e-05,
-      "loss": 0.2963,
-      "step": 140000
-    },
-    {
-      "epoch": 1.14,
-      "learning_rate": 1.771581600504096e-05,
-      "loss": 0.3031,
-      "step": 145000
-    },
-    {
-      "epoch": 1.18,
-      "learning_rate": 1.7637051039697544e-05,
-      "loss": 0.3033,
-      "step": 150000
-    },
-    {
-      "epoch": 1.18,
-      "eval_accuracy": 0.9257162809371948,
-      "eval_loss": 0.4006378650665283,
-      "eval_runtime": 519.4649,
-      "eval_samples_per_second": 54.421,
-      "eval_steps_per_second": 13.606,
-      "step": 150000
-    },
-    {
-      "epoch": 1.22,
-      "learning_rate": 1.755828607435413e-05,
-      "loss": 0.3024,
-      "step": 155000
-    },
-    {
-      "epoch": 1.26,
-      "learning_rate": 1.7479521109010713e-05,
-      "loss": 0.3135,
-      "step": 160000
-    },
-    {
-      "epoch": 1.3,
-      "learning_rate": 1.74007561436673e-05,
-      "loss": 0.3137,
-      "step": 165000
-    },
-    {
-      "epoch": 1.34,
-      "learning_rate": 1.732199117832388e-05,
-      "loss": 0.3227,
-      "step": 170000
-    },
-    {
-      "epoch": 1.38,
-      "learning_rate": 1.7243226212980467e-05,
-      "loss": 0.3246,
-      "step": 175000
-    },
-    {
-      "epoch": 1.38,
-      "eval_accuracy": 0.924018383026123,
-      "eval_loss": 0.3924681842327118,
-      "eval_runtime": 518.8244,
-      "eval_samples_per_second": 54.489,
-      "eval_steps_per_second": 13.623,
-      "step": 175000
-    },
-    {
-      "epoch": 1.42,
-      "learning_rate": 1.7164461247637053e-05,
-      "loss": 0.3281,
-      "step": 180000
-    },
-    {
-      "epoch": 1.46,
-      "learning_rate": 1.708569628229364e-05,
-      "loss": 0.3256,
-      "step": 185000
-    },
-    {
-      "epoch": 1.5,
-      "learning_rate": 1.700693131695022e-05,
-      "loss": 0.313,
-      "step": 190000
-    },
-    {
-      "epoch": 1.54,
-      "learning_rate": 1.6928166351606807e-05,
-      "loss": 0.3313,
-      "step": 195000
-    },
-    {
-      "epoch": 1.58,
-      "learning_rate": 1.684940138626339e-05,
-      "loss": 0.2953,
-      "step": 200000
-    },
-    {
-      "epoch": 1.58,
-      "eval_accuracy": 0.9212592840194702,
-      "eval_loss": 0.3895967900753021,
-      "eval_runtime": 526.2623,
-      "eval_samples_per_second": 53.718,
-      "eval_steps_per_second": 13.431,
-      "step": 200000
-    },
-    {
-      "epoch": 1.61,
-      "learning_rate": 1.6770636420919976e-05,
-      "loss": 0.3103,
-      "step": 205000
-    },
-    {
-      "epoch": 1.65,
-      "learning_rate": 1.669187145557656e-05,
-      "loss": 0.3089,
-      "step": 210000
-    },
-    {
-      "epoch": 1.69,
-      "learning_rate": 1.6613106490233147e-05,
-      "loss": 0.3095,
-      "step": 215000
-    },
-    {
-      "epoch": 1.73,
-      "learning_rate": 1.653434152488973e-05,
-      "loss": 0.3288,
-      "step": 220000
-    },
-    {
-      "epoch": 1.77,
-      "learning_rate": 1.6455576559546316e-05,
-      "loss": 0.3199,
-      "step": 225000
-    },
-    {
-      "epoch": 1.77,
-      "eval_accuracy": 0.9203749299049377,
-      "eval_loss": 0.3942428529262543,
-      "eval_runtime": 520.6801,
-      "eval_samples_per_second": 54.294,
-      "eval_steps_per_second": 13.575,
-      "step": 225000
-    },
-    {
-      "epoch": 1.81,
-      "learning_rate": 1.6376811594202898e-05,
-      "loss": 0.306,
-      "step": 230000
-    },
-    {
-      "epoch": 1.85,
-      "learning_rate": 1.6298046628859484e-05,
-      "loss": 0.3104,
-      "step": 235000
-    }
-  ],
-  "max_steps": 1269600,
-  "num_train_epochs": 10,
-  "total_flos": 2.473283070586798e+17,
-  "trial_name": null,
-  "trial_params": null
-}

pytorch_model.bin → variables/variables.data-00000-of-00001

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5adefcec339329c7c3d2ef2c94a00bf7f19a361c6808d54a7a987169f372f491
-size 438084653
+oid sha256:e3c27336aaecafd070749d833780e6603b9c25caf01a037c0ef9a93ff3b0c36c
+size 63405929

training_args.bin → variables/variables.index

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:561b187687b39a679c0f6eebbf20fc3ece81123ada2b8481d039e8076a99fef3
-size 2991
+oid sha256:c109c3a99fb1bfbd8298c3f63cfee52e1bd8e8f10f138796eddbac360eaa0de1
+size 17873