What Makes Molmo and PixMo Sport-Changers in VLMs?

Essentially the most highly effective VLMs obtainable as we speak stay proprietary, limiting open analysis exploration. Open fashions usually lag because of dependency on artificial knowledge generated by proprietary fashions, proscribing true openness. Molmo, a complicated vision-language mannequin, seeks to bridge this hole by creating high-quality multimodal capabilities constructed from open datasets and impartial coaching strategies.

PixMo, the accompanying dataset, was designed to beat the normal limitations of knowledge accessibility in VLM improvement. The group collected in depth image-caption pairs utilizing human speech annotations, which resulted in high-density captions free from the constraints of artificial datasets.

Molmo’s structure follows an ordinary multimodal design: it combines a imaginative and prescient encoder and a language mannequin to create a vision-language mannequin able to processing each photos and textual content.

Overview

• PixMo Datasets (the success issue for Molmo)
• Key Parts of the Molmo Structure
  • Picture Pre-processor: Converts enter photos right into a set of multi-scale, multi-crop sections.
  • Imaginative and prescient Encoder (CLIP ViT-L/14 336px)
  • Connector (MLP-based projection): Projection of picture embeddings to language mannequin’s dimension.
  • Decoder-Solely Transformer LLM.
• Coaching Pipeline: Two Phases
  • Multimodal Pre-Coaching for Caption Technology
  • Supervised Nice-Tuning on Various Duties
• Analysis of Molmo on 11 benchmark datasets
• Palms-on experimentation with Molmo (code)

PixMo Datasets – the Essential element of Molmo’s success

• PixMo-Cap: Annotators had been requested to explain photos in speech for 60-90 seconds, offering detailed and dense picture captions. The speech was additional transcribed and handed by a language mannequin to wash the textual content (take away spoken artifacts, normalize model). The info comprises detailed, dense captions for over 712k photos.
• PixMo-AskModelAnything: Annotators generate numerous question-answer pairs with photos.
• PixMo-Factors: This dataset contains point-based annotations, enabling Molmo to level, reply location-based questions, and rely objects straight by pointing, including a spatial dimension to visible understanding.
• Different datasets: These embody artificial clock datasets (query answering on analog clocks) (PixMo-Clocks) and document-heavy datasets (PixMo-Docs, PixMo-CapQA).

Complete element of the Structure of Molmo and its Design Choices:

Enter Processing: Multi-Scale, Multi-Crop Pictures

The enter to Molmo is generated by making use of multi-scale and multi-crop transformations to the unique picture. In multi-crop coaching, a number of crops (sections) of the identical picture are taken from totally different areas, usually at numerous scales and resolutions. Every crop offers a unique perspective or focus space of the picture.

• Function: Multi-crop coaching is designed to provide the mannequin a richer, extra numerous understanding of the whole picture by exposing it to extra particulars and views. This helps it generalize higher, particularly on high-resolution photos with advanced scenes.

Imaginative and prescient Encoder: OpenAI’s ViT-L/14 336px CLIP Mannequin

The core of Molmo’s visible processing is OpenAI’s CLIP (Contrastive Language Picture-Pretraining) mannequin, a robust Imaginative and prescient Transformer (ViT) optimized for high-resolution inputs.

• Why did Molmo select OpenAI’s CLIP as a substitute of SigLIP?: By experimentation, CLIP proved superior to options like SigLIP in dealing with multi-scale, multi-crop, and high-resolution knowledge. However, SigLIP performs higher in single-crop situations however struggles with the calls for of multi-crop coaching, probably lacking out on the richer contextual understanding that Molmo requires.
• Mathematical and Conceptual Instinct: CLIP’s structure makes use of consideration layers that weigh the significance of picture patches based mostly on spatial and feature-related relevance. Every patch successfully attends to others, forming a complete picture illustration. This aligns effectively with multi-scale processing as a result of CLIP can leverage each native patch particulars and the broader context in its remaining tokenized illustration. SigLIP’s less complicated processing pipeline probably restricted its capacity to generalize as successfully below related situations.

Connector: Multi-Layer Perceptron (MLP) and Pooling

The connector is a fastidiously constructed MLP that tasks the high-dimensional tokens from CLIP to match the enter house (dimensions) the language mannequin requires. Following this projection, a pooling layer performs dimensionality discount, making certain the visible tokens are condensed to a manageable measurement for the language mannequin with out sacrificing key visible particulars.

Dimensionality Discount By Pooling: Pooling selects and averages key options throughout the visible tokens. Conceptually, this may be regarded as a abstract of visible data—simply sufficient element to tell the language mannequin with out overwhelming it.
Instance: Think about a cityscape picture divided into 100 tokens by the imaginative and prescient encoder. Pooling condenses these tokens by summarizing key options, prioritizing outstanding constructions (like buildings), and lowering redundancy in repetitive areas (just like the sky). This ends in a smaller, targeted set of round 20 tokens, capturing solely probably the most important particulars for environment friendly processing by the language mannequin.

Language Mannequin (LLM): Decoder-Solely Transformer

Molmo’s imaginative and prescient encoder stays constant throughout variants, using CLIP’s ViT-L/14 mannequin for all variations. Nevertheless, Molmo’s LLM element varies based mostly on necessities for capability, openness, and compute effectivity:

• Mannequin Variants for Language Processing: Molmo offers flexibility by permitting numerous LLMs, together with OLMo (7B-1024), OLMoE-1B-7B, and bigger fashions like Qwen2 and Mistral. These LLMs differ of their parameter scales and openness, from environment friendly smaller fashions to high-capacity variants able to dealing with advanced language and picture interactions.
• Reasoning Behind A number of LLMs: By providing quite a lot of LLMs, Molmo can cater to numerous wants. Smaller fashions are sooner and fewer compute-intensive, whereas bigger fashions are suited to duties that require extra nuanced language processing and deeper contextual understanding.

In transformers, decoder-only structure is especially suited to duties requiring context-based era, reminiscent of captioning or question-answering. The mannequin “decodes” tokens in a self-referential method, with every token attending to all earlier tokens to construct a coherent output, guided by each visible and textual cues from earlier phases.

Coaching Pipeline: Two Easy Phases

Molmo’s coaching is split into two main phases that contribute to mannequin’s excessive efficiency and flexibility:

Stage 1: Multimodal Pre-Coaching for Caption Technology

Objective: Practice the mannequin to generate detailed, correct captions for photos. PixMo-Cap dataset is used on this step.

Molmo makes use of a less complicated, single-stage pre-training technique for caption era, which avoids the complexity and potential inefficiencies of multi-stage pre-training (e.g., freezing elements of the mannequin/community at totally different phases).

Why Molmo Avoids Multi-Stage Pre-training?

Molmo’s less complicated, single-stage pre-training works effectively in its context as a result of:

• It makes use of high-quality human-annotated knowledge from the beginning, which avoids the necessity for progressive fine-tuning throughout phases. This is without doubt one of the key differentiators between Molmo and different fashions that depend on weakly labeled or artificial knowledge.
• Molmo’s imaginative and prescient encoder (e.g., CLIP) and language mannequin are each off-the-shelf and are fine-tuned collectively in a single go, avoiding the inefficiency of multi-stage fine-tuning.
• Effectivity: Coaching all elements collectively (single-stage pre-training) permits the mannequin to converge sooner and simplifies the coaching pipeline.

Stage 2: Supervised Nice-Tuning on Various Duties

After pre-training for caption era, Molmo is fine-tuned on a combination of datasets, together with normal tutorial datasets and extra PixMo datasets like PixMo-AskModelAnything, PixMo-Factors, PixMo-Clocks, and PixMo-Docs. The fine-tuning contains supervised coaching knowledge for duties like query answering, counting, and point-based referencing.

• Why No RLHF (Reinforcement Studying with Human Suggestions)? Molmo doesn’t use RLHF, which is often employed in fashions like GPT-4, to refine efficiency by human interplay. As an alternative, Molmo depends on high-quality labelled knowledge for fine-tuning. The concept right here is that Molmo’s complete dataset already encompasses a broad set of real-world duties, obviating the necessity for additional human suggestions throughout coaching.

Analysis: Tutorial Benchmarks and Human Desire

Evaluating multimodal fashions will be difficult as a result of complexity of visible and linguistic duties. The Molmo group gauged efficiency utilizing a mixture of educational benchmarks and in depth human evaluations.

1. Tutorial Benchmarks: Molmo was examined towards 11 broadly used datasets, together with VQA, DocVQA, and a brand new counting-focused benchmark, Flickr Depend. The fashions to be in contrast are categorized into 4 teams: proprietary fashions that may solely be accessed by API calls, fashions with launched weights however closed knowledge, fashions with launched weights and launched coaching knowledge, and the Molmo household of fashions. The outcomes positioned Molmo fashions alongside and even above proprietary programs like GPT-4V, particularly the 72B variant.
2. Human Desire Testing: To complement quantitative scores, Molmo’s human desire testing concerned gathering over 325,000 pairwise comparisons, and rating fashions on person satisfaction. Molmo-72B achieved one of many highest rankings, trailing solely proprietary fashions like GPT-4o in direct person desire.

Comparability with Different Fashions (LLaVA, Qwen2-VL, PaliGemma)

• LLaVA and Qwen2-VL: These fashions depend on multi-stage pre-training, usually involving frozen elements of the mannequin throughout totally different phases. They use large-scale, artificial knowledge, which helps with scale however introduces noise and reliance on proprietary VLMs.
• PaliGemma: Much like Qwen2-VL, it makes use of closed knowledge and is determined by artificial knowledge generated by proprietary fashions. Molmo avoids these dependencies, making certain transparency and reproducibility.

Additionally learn: Palms-On Multimodal Retrieval and Interpretability (ColQwen + Vespa)

A Palms-on Information for working Molmo on our use case:

Now that we’re clear with the structure of Molmo let’s get hands-on and check out some examples with Molmo. On this part, we’ll stroll by utilizing Molmo on instance photos to extract structured data. This hands-on session will enable you perceive the best way to load the mannequin, course of photos, generate outputs, and customise it on your personal knowledge.

Colab pocket book: Molmo-VLM-handson.ipynb (I’ve used A100 Excessive-Ram GPU for working these experiments)

1. Setting Up the Atmosphere

First, we have to set up some important packages. These embody transformers for mannequin processing, torch for dealing with tensors, Pillow for picture manipulation, and pytesseract for OCR (Optical Character Recognition).

!pip set up -q transformers torch Pillow einops
!pip set up -q pytesseract
!apt-get set up -y tesseract-ocr

2. Loading the Molmo Mannequin and Processor

Right here, we specify the Molmo mannequin we need to use (on this case, MolmoE-1B-0924) and cargo it together with its processor.

from transformers import AutoModelForCausalLM, AutoProcessor, GenerationConfig
from PIL import Picture
import torch

model_name="allenai/MolmoE-1B-0924"
processor = AutoProcessor.from_pretrained(model_name, trust_remote_code=True, torch_dtype="auto", device_map='auto')
mannequin = AutoModelForCausalLM.from_pretrained(model_name, trust_remote_code=True, torch_dtype="auto", device_map='auto')

mannequin.to("cuda")

AutoProcessor prepares the inputs for Molmo, dealing with each photos and textual content prompts. AutoModelForCausalLM hundreds the language mannequin. Setting device_map=’auto’ ensures the mannequin is loaded onto the very best obtainable gadget (like GPU) for sooner efficiency.

3. Processing and Displaying an Picture

To work with a picture, we load it utilizing Pillow and show it to substantiate we’ve got the proper enter.

image_path="your_image.png"  # present the picture path right here
picture = Picture.open(image_path).convert('RGB')
picture

This code hundreds a picture from the required path and converts it to RGB format, making certain compatibility with the mannequin.

Resizing the Picture for Consistency

If a picture is just too giant, you possibly can resize it for constant processing after which show the picture. This operate resizes photos with a top larger than 800 pixels. Lowering picture measurement can optimize processing with out considerably affecting the mannequin’s capacity to interpret content material.

def resize_image(picture, max_height=800):
    width, top = picture.measurement
    if top > max_height:
        ratio = max_height / top
        new_width = int(width * ratio)
        new_height = int(top * ratio)
        return picture.resize((new_width, new_height))
    return picture

4. Processing Picture and Textual content for Mannequin Enter

We outline a textual content immediate and course of each the picture and textual content collectively utilizing the processor.

inputs = processor.course of(
    photos=[image],
    textual content="Extract all the data from the web page in JSON format, particularly the account abstract and all contact particulars in correct format."
)

inputs = {okay: v.to(mannequin.gadget).unsqueeze(0) for okay, v in inputs.gadgets()}

The processor combines the picture and textual content right into a format the mannequin can interpret. Every enter is moved to the mannequin’s gadget (often GPU) and reshaped for batch processing.

5. Producing the Output Textual content

Utilizing the mannequin’s generate_from_batch operate, we generate an output based mostly on the picture and immediate.

output = mannequin.generate_from_batch(
    inputs,
    GenerationConfig(max_new_tokens=500, stop_strings="<|endoftext|>"),
    tokenizer=processor.tokenizer
)

generated_tokens = output[0, inputs['input_ids'].measurement(1):]
generated_text = processor.tokenizer.decode(generated_tokens, skip_special_tokens=True)

print(generated_text)

Right here, we set a most restrict of 500 tokens (you possibly can enhance or lower the variety of tokens in line with your usecase) for the response and outline a cease situation (<|endoftext|>). This line (output[0, inputs[‘input_ids’].measurement(1):] ) extracts solely the generated tokens with slicing which skips the enter immediate tokens within the output. This isolates the newly generated tokens and avoids redundancy in responses. 

The mannequin processes the inputs and generates tokens representing the textual content output, which we then decode to human-readable textual content. This enables us to see Molmo’s extracted data based mostly on our immediate.

General operate which takes an image_path and a immediate and can generate textual content as instructed

def generate_text(image_path, immediate):
   picture = Picture.open(image_path).convert('RGB')
   inputs = processor.course of(
       photos=[image],
       textual content=immediate
   )
  inputs = {okay: v.to(mannequin.gadget).unsqueeze(0) for okay, v in inputs.gadgets()}
   output = mannequin.generate_from_batch(
       inputs,
       GenerationConfig(max_new_tokens=500, stop_strings="<|endoftext|>"),
       tokenizer=processor.tokenizer
   )
   generated_tokens = output[0,inputs['input_ids'].measurement(1):]
   generated_text = processor.tokenizer.decode(generated_tokens, skip_special_tokens=True)
   return picture, generated_text

You possibly can move customized prompts to refine the mannequin’s focus. On this case, we’re asking for detailed data, specifying a JSON format for structured knowledge extraction. This helps Molmo return knowledge that’s prepared for additional processing or evaluation.

The picture from which we’re extracting knowledge:

input_path="/content material/Visualization - Binary Quantization.png"

immediate=""'You're an knowledgeable mathematician. You must perceive what's been talked about on this web page and description the subjects together with rationalization.
The output needs to be in json format with keys "subjects talked about", "rationalization": {"exp_topic1", "exp_topic2", ...}
'''

picture, generated_text = generate_text(input_path, immediate)
resize_image(picture)
print(generated_text)

Output:

{
"subjects talked about": [
"Query and token",
"Binary quantization",
"Hamming distance",
"Minimum Hamming distance",
"Query and token embeddings",
"Final hamming similarity"
],
"rationalization": {
"question and token": "The picture discusses the method of changing every
worth in a question or token into both 1 or 0, relying on whether or not it
represents a constructive or destructive worth respectively. This method is used
in binary quantization.",
"binary quantization": "This can be a technique for representing actual numbers in
binary format with a hard and fast variety of bits. The picture explains the best way to convert
floating-point numbers to binary after which calculate the Hamming distance
between two binary vectors.",
"Hamming distance": "This can be a measure of what number of bit positions differ
between two binary vectors. The picture reveals the best way to calculate this distance
between two binary vectors of various lengths.",
"minimal Hamming distance": "This refers back to the shortest distance between
two vectors of the identical size, excluding the vector itself. The picture
offers formulation for calculating this distance for various token sizes
and question lengths.",
"question and token embeddings": "The picture describes the best way to characterize question
and token knowledge in a four-dimensional house utilizing multi-vector embeddings. It
explains the method of tokenization and the usage of binary quantization for
this illustration.",
"remaining hamming similarity": "The picture concludes by discussing the
calculation of total hamming similarity between two question vectors and
their embeddings"
}
}

We are able to additionally take a fancy instance the place there are a lot of tables and see how a lot knowledge the mannequin can extract in a single go:

input_path="/content material/0fa82bab-e131-43dd-86da-7153b2ecc76d.png"

immediate=""'Extract all the data from the web page in json, each knowledge must be current. Do not miss out on contact particulars, title, tackle, account invoice abstract, billing historical past and methods to pay.
The output needs to be in json format with keys being all the info discovered within the web page. Info is essential.
'''

picture, generated_text = generate_text(input_path, immediate, max_tokens=1000)
print(generated_text)
resize_image(picture, max_height=600) # displaying the picture my resizing it 600 pixels top

Output:

{
"energyStatement": {
"accountNumber": "5553220335-0",
"statementDate": "01/30/2024",
"dueDate": "02/20/2024",
"web site": "www.pge.com/myenergy",
"serviceInfo": {
"meterNumber": "10098180854",
"totalUsage": "518.53 MWh",
" rotatingOutageBlock": "10F",
"serviceID": "5534591016"
},
"billingHistory": {
"billingcycles": "33 billing cycles",
"billingcyclesToDate": "12/31/2023",
"currentBillingcycle": "12/22/2023"
},
"serviceSchedule": {
"serviceID": "5534591016",
"schedule": "EVA Residence Charging"
},
"electricDeliveryCharges": {
"complete": "$139.29",
"2018VintagePowerChargeInferenceAdjustment": "1.00"
},
"contactInfo": {
"phoneNumber": "555-123-4567",
"electronic mail": "[email protected]"
}
}
}

From the above picture, as we will see in on the go, many of the particulars are extracted, however what if we don’t need to miss a single piece of knowledge from the web page and the web page is dense with data? There, we will attempt an strategy to separate the picture into a number of patches and move these patches individually to the mannequin to extract knowledge that we will ultimately mix collectively.

Splitting the Picture into Patches

To deal with advanced photos with numerous areas, break up them into smaller patches and course of every patch individually. Right here, we’re following a simple strategy of splitting the picture into 4 equal sections. That is helpful for big paperwork the place totally different areas might include distinct data, and in addition sections are equally divided (like analysis papers).

def split_image_into_patches(picture):
    width, top = picture.measurement
    patches = {
        "top_left": picture.crop((0, 0, width // 2, top // 2)),
        "top_right": picture.crop((width // 2, 0, width, top // 2)),
        "bottom_left": picture.crop((0, top // 2, width // 2, top)),
        "bottom_right": picture.crop((width // 2, top // 2, width, top))
    }
    return patches

Processing Every Patch and Extracting Info

Every patch is processed individually with a immediate to extract related particulars. We retailer every patch’s end in a dictionary.

extracted_data = {}
for patch_name, patch_image in image_patches.gadgets():
    inputs = processor.course of(
        photos=[patch_image],
        textual content="Extract all the data from web page in JSON, each knowledge must be current."
    )
    inputs = {okay: v.to(mannequin.gadget).unsqueeze(0) for okay, v in inputs.gadgets()}
    output = mannequin.generate_from_batch(
        inputs,
        GenerationConfig(max_new_tokens=500, stop_strings="<|endoftext|>"),
        tokenizer=processor.tokenizer
    )
    generated_tokens = output[0, inputs['input_ids'].measurement(1):]
    generated_text = processor.tokenizer.decode(generated_tokens, skip_special_tokens=True)
    extracted_data[patch_name] = generated_text

The above strategy of splitting photos equally is just like splitting an extended textual content doc into fixed-length textual content chunks. Nevertheless, if the chunks are divided between a unbroken textual content then we lose context. This idea applies to pictures too. So, as a substitute of splitting the picture equally, what if we break up the picture based mostly on visually semantic chunks.

We might be attempting out a easy strategy right here: combining OCR with calculating the road hole in bounding packing containers to create a bunch of patches from a picture after which move these patches to the Molmo mannequin. 

We are able to apply OCR to determine textual content areas within the picture and return the textual content together with bounding packing containers.

import pytesseract

def extract_text_regions(picture):
    ocr_data = pytesseract.image_to_data(picture, output_type=pytesseract.Output.DICT)
    text_regions = []
    for i, phrase in enumerate(ocr_data['text']):
        if phrase.strip():  # Ignore empty strings
            x, y, w, h = ocr_data['left'][i], ocr_data['top'][i], ocr_data['width'][i], ocr_data['height'][i]
            text_regions.append({
                "textual content": phrase,
                "bbox": (x, y, x + w, y + h)
            })
    return text_regions

Grouping and Processing Semantic Chunks

We are able to group textual content areas into logical chunks (like paragraphs or tables) for extra logical extraction. This operate teams phrases into bigger chunks, like strains or paragraphs, based mostly on their bounding field positions (calculation of vertical line hole between bounding packing containers). It’s helpful for extracting extra contextually coherent data from paperwork.

def group_text_regions(text_regions, line_threshold=10):
    grouped_regions = []
    current_group = []
    last_bottom = -1

    for area in text_regions:
        _, prime, _, backside = area['bbox']
        if last_bottom != -1 and (prime - last_bottom > line_threshold):
            grouped_regions.append(current_group)
            current_group = []
        current_group.append(area)
        last_bottom = backside

    if current_group:
        grouped_regions.append(current_group)
    
    return grouped_regions

Now, we are going to apply this strategy on a web page to create teams and move every patch to the mannequin for extraction. As soon as all of the json knowledge are extracted, we will move it to an LLM to mix all the things collectively.

# Apply OCR to determine textual content areas
text_regions = extract_text_regions(picture)

# Group textual content areas into semantic chunks
semantic_chunks = group_text_regions(text_regions)

# Initialize a dictionary to retailer extracted knowledge from every chunk
extracted_data = {}

# Loop by every semantic chunk, course of, and retailer the output
for idx, chunk in enumerate(semantic_chunks):
   # Create a bounding field for the chunk
   x_min = min([r['bbox'][0] for r in chunk])
   y_min = min([r['bbox'][1] for r in chunk])
   x_max = max([r['bbox'][2] for r in chunk])
   y_max = max([r['bbox'][3] for r in chunk])

   # Crop the picture to the bounding field of the chunk
   chunk_image = picture.crop((x_min, y_min, x_max, y_max))

   # Put together textual content immediate for Molmo
   chunk_text = " ".be a part of([r['text'] for r in chunk])
   prompt_text = f"Extract data from this part: {chunk_text} in JSON format."

   # Course of the chunk picture and immediate with Molmo
   inputs = processor.course of(
       photos=[chunk_image],
       textual content=prompt_text
   )
   inputs = {okay: v.to(mannequin.gadget).unsqueeze(0) for okay, v in inputs.gadgets()}

   output = mannequin.generate_from_batch(
       inputs,
       GenerationConfig(max_new_tokens=500, stop_strings="<|endoftext|>"),
       tokenizer=processor.tokenizer
   )

   generated_tokens = output[0, inputs['input_ids'].measurement(1):]
   generated_text = processor.tokenizer.decode(generated_tokens, skip_special_tokens=True)
   print(generated_text, "nn")

   # Retailer the extracted knowledge for the present chunk
   extracted_data[f"chunk_{idx}"] = generated_text

# Mix all extracted knowledge
combined_data = { "page_summary": extracted_data }

This was a enjoyable experiment, however it’s not but the best-optimized strategy. We are able to enhance it additional through the use of segmentation to create logical chunks. If we plan to make use of OCR, then grouping must be extra strict and heuristic-based (contemplating each vertical and horizontal line gaps and a few checks on the quantity of textual content or knowledge obtainable).

Conclusion

On this deep dive into Molmo and PixMo, we explored the motivations behind growing open and sturdy vision-language fashions, the detailed structure of Molmo, and the distinctive datasets powering its capabilities. We walked by key design choices, together with why Molmo opted for a less complicated, single-stage coaching pipeline and selected CLIP because the imaginative and prescient encoder for its superior efficiency in dealing with multi-crop, high-resolution photos. The hands-on part showcased Molmo’s flexibility in extracting advanced structured knowledge, offering you with sensible examples and code to check out your self. By embracing transparency, high-quality knowledge, and environment friendly coaching methods, Molmo units a brand new normal in open multimodal analysis, providing a flexible software for tackling numerous vision-language duties. We’ve got come to the top of the weblog. I hope this weblog offers a complete understanding of Molmo and conjures up you to experiment with its capabilities.

Additionally, if you’re in search of a generative AI course on-line, then discover: GenAI Pinnacle Program

Ceaselessly Requested Questions

Hello, I am Antaripa Saha, Machine Studying Engineer II at a US-based startup. I’m keen about math, generative AI, and the newest developments in VLMs and LLMs. I like deep-diving analysis papers and breaking them down in my blogs.
My twitter profile: https://twitter.com/doesdatmaksense